{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 分类训练\n",
    "## 机器学习的HelloWorld，一个新的分类算法，都会看看在MNIS的执行结果"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 解包读取MNIST数据"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "b'\\x00\\x00\\x00\\x02'"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import struct # 导入字节解包\n",
    "struct.pack('>i',2) # 高位字节  把2打包成整型，4个字节，pack打包。unpack解包"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "b'\\x14'"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "struct.pack('>B',20) # 把20打包成一个字节"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(2051, 60000, 28, 28)\n",
      "47040000\n"
     ]
    }
   ],
   "source": [
    "# 解压gz文件，右键有TZ解压\n",
    "# 读取4个int字节，打印魔法数字、图片张数，行数，列数与总共像素\n",
    "with open('./MNIS_data/train-images.idx3-ubyte','rb') as f:\n",
    "    buffer = f.read(4*4) # 4个int\n",
    "    head = struct.unpack('>iiii',buffer) # 解压buffer字节成4个int\n",
    "    print(head) # 打印魔法数字、图片张数，行数，列数\n",
    "    length = head[1] * head[2] * head[3] # 总共像素\n",
    "    print(length) # 打印总共像素\n",
    "    buffer = f.read(length) # 读取后面整个像素包\n",
    "    data = struct.unpack('>{}B'.format(length),buffer) # 解压length字节"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "47040000"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len(data)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tuple"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(data)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "imgs = np.reshape(data,(head[1],head[2],head[3])) # 三维数组"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(60000, 28, 28)"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "imgs.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "for i in range(5):\n",
    "    plt.imshow(imgs[i], cmap = 'gray') # 第一个参数是图像的np数组，cmap色域设置\n",
    "    plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "c:\\users\\tians\\appdata\\local\\programs\\python\\python37\\lib\\site-packages\\sklearn\\feature_extraction\\text.py:17: DeprecationWarning: Using or importing the ABCs from 'collections' instead of from 'collections.abc' is deprecated, and in 3.8 it will stop working\n",
      "  from collections import Mapping, defaultdict\n"
     ]
    }
   ],
   "source": [
    "# 另一种解包方式加载mat文件，更方便\n",
    "from sklearn.datasets import fetch_mldata\n",
    "mnist = fetch_mldata('MNIST original',data_home = './') # 既可以从网络上抓取，也可以在本地抓取，把data_home去掉，直接传url地址"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'DESCR': 'mldata.org dataset: mnist-original',\n",
       " 'COL_NAMES': ['label', 'data'],\n",
       " 'target': array([0., 0., 0., ..., 9., 9., 9.]),\n",
       " 'data': array([[0, 0, 0, ..., 0, 0, 0],\n",
       "        [0, 0, 0, ..., 0, 0, 0],\n",
       "        [0, 0, 0, ..., 0, 0, 0],\n",
       "        ...,\n",
       "        [0, 0, 0, ..., 0, 0, 0],\n",
       "        [0, 0, 0, ..., 0, 0, 0],\n",
       "        [0, 0, 0, ..., 0, 0, 0]], dtype=uint8)}"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mnist # 字典，data理解为独热编码"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "    * ESCR 数据集描述\n",
    "    * data 包含一个数组，每个实例为一行，每个特征为一列\n",
    "    * target 包含一个带有标签的数组"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "X,y = mnist['data'], mnist['target']  # X为整体样本数据"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(70000, 784)"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "X.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(70000,)"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "y.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "%matplotlib inline\n",
    "import matplotlib\n",
    "import matplotlib.pyplot as plt"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "some_digit = X[36000]  # 经常用到\n",
    "some_digit_image = some_digit.reshape(28,28) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.imshow(some_digit_image, cmap = matplotlib.cm.binary) # binary代表白底黑字\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5.0"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "y[36000]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 建立测试集和训练集"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "X_train,X_test,y_train,y_test = X[:60000], X[60000:], y[:60000], y[60000:]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 9445, 59469, 33158, ..., 58240, 49259, 46563])"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 将数据集合交叉洗牌，交叉验证时，每个子集合数据分布均匀，有些机器学习算法对训练实例的顺序敏感\n",
    "shuffle_index = np.random.permutation(60000) # 洗牌，如果不洗牌，可能会遇到连续相同的图，可能导致训练效果不好\n",
    "shuffle_index"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [],
   "source": [
    "X_train,y_train = X_train[shuffle_index], y_train[shuffle_index] # 被打乱的下标取值"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0, 0, 0, ..., 0, 0, 0],\n",
       "       [0, 0, 0, ..., 0, 0, 0],\n",
       "       [0, 0, 0, ..., 0, 0, 0],\n",
       "       ...,\n",
       "       [0, 0, 0, ..., 0, 0, 0],\n",
       "       [0, 0, 0, ..., 0, 0, 0],\n",
       "       [0, 0, 0, ..., 0, 0, 0]], dtype=uint8)"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "X_train"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 训练一个二元分类器"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([False, False,  True, ..., False, False, False])"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 识别数字5，二元分类5或者非5\n",
    "# 创建目标向量\n",
    "y_train_5 = (y_train == 5) # 可以写5，或者5.0，也可以不用括号，因为==优先级高于 = \n",
    "y_train_5"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[False, False,  True, ...,  True, False, False],\n",
       "       [ True, False, False, ..., False, False, False],\n",
       "       [False, False, False, ..., False, False, False],\n",
       "       ...,\n",
       "       [False, False, False, ..., False, False, False],\n",
       "       [False, False, False, ..., False,  True, False],\n",
       "       [False, False, False, ..., False, False, False]])"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "y_train_5.reshape(20,-1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([False, False, False, ..., False, False, False])"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "y_test_5 = (y_test == 5)\n",
    "y_test_5"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "c:\\users\\tians\\appdata\\local\\programs\\python\\python37\\lib\\site-packages\\sklearn\\linear_model\\stochastic_gradient.py:128: FutureWarning: max_iter and tol parameters have been added in <class 'sklearn.linear_model.stochastic_gradient.SGDClassifier'> in 0.19. If both are left unset, they default to max_iter=5 and tol=None. If tol is not None, max_iter defaults to max_iter=1000. From 0.21, default max_iter will be 1000, and default tol will be 1e-3.\n",
      "  \"and default tol will be 1e-3.\" % type(self), FutureWarning)\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "array([ True])"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# SGD梯度下降 分类器，适合非常大的数据集，独立处理训练集数据，一次一个，适合在线学习\n",
    "from sklearn.linear_model import SGDClassifier  # SGDClassifier是一种估算器\n",
    "\n",
    "sgd_cif = SGDClassifier(random_state = 42) # random_state相当于随机因子，每次分类会保持一致\n",
    "sgd_cif.fit(X_train,y_train_5)\n",
    "\n",
    "sgd_cif.predict([some_digit]) # 训练数据有两个括号，代表二维数组"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 性能考核"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 使用交叉验证测量精度"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "c:\\users\\tians\\appdata\\local\\programs\\python\\python37\\lib\\site-packages\\sklearn\\linear_model\\stochastic_gradient.py:128: FutureWarning: max_iter and tol parameters have been added in <class 'sklearn.linear_model.stochastic_gradient.SGDClassifier'> in 0.19. If both are left unset, they default to max_iter=5 and tol=None. If tol is not None, max_iter defaults to max_iter=1000. From 0.21, default max_iter will be 1000, and default tol will be 1e-3.\n",
      "  \"and default tol will be 1e-3.\" % type(self), FutureWarning)\n",
      "c:\\users\\tians\\appdata\\local\\programs\\python\\python37\\lib\\site-packages\\sklearn\\linear_model\\stochastic_gradient.py:128: FutureWarning: max_iter and tol parameters have been added in <class 'sklearn.linear_model.stochastic_gradient.SGDClassifier'> in 0.19. If both are left unset, they default to max_iter=5 and tol=None. If tol is not None, max_iter defaults to max_iter=1000. From 0.21, default max_iter will be 1000, and default tol will be 1e-3.\n",
      "  \"and default tol will be 1e-3.\" % type(self), FutureWarning)\n",
      "c:\\users\\tians\\appdata\\local\\programs\\python\\python37\\lib\\site-packages\\sklearn\\linear_model\\stochastic_gradient.py:128: FutureWarning: max_iter and tol parameters have been added in <class 'sklearn.linear_model.stochastic_gradient.SGDClassifier'> in 0.19. If both are left unset, they default to max_iter=5 and tol=None. If tol is not None, max_iter defaults to max_iter=1000. From 0.21, default max_iter will be 1000, and default tol will be 1e-3.\n",
      "  \"and default tol will be 1e-3.\" % type(self), FutureWarning)\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "array([0.9582 , 0.95875, 0.96335])"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 评估分类器比评估回归器要困难地多\n",
    "\n",
    "# 3个折叠，正确率达到95%以上\n",
    "from sklearn.model_selection import cross_val_score\n",
    "cross_val_score(sgd_cif,X_train,y_train_5,cv=3,scoring='accuracy') # 采取accuracy方式评估，而不是方差方式，CV默认值为10"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 把每张图片都分类成 非5\n",
    "from sklearn.base import BaseEstimator\n",
    "class Never5Classifier(BaseEstimator):\n",
    "    def fit(self,X,y=None):\n",
    "        pass\n",
    "    def predict(self,X):\n",
    "        return np.zeros((len(X),1), dtype=bool)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0.90715, 0.9086 , 0.9132 ])"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "never_5_cif = Never5Classifier()\n",
    "cross_val_score(never_5_cif,X_train,y_train_5, cv=3,scoring='accuracy')\n",
    "# 分类器是单一维度，准确性不能确保"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "    * 准确率超过90% ，因为5的图像大约只有10%，你猜一张图不是5， 90%的时间你都是正确的\n",
    "    * 这说明准确率无法成为分类器的首要性能指标，特别是当你处理偏科数据集， 某些类比其他类更为频繁"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 混淆矩阵"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "c:\\users\\tians\\appdata\\local\\programs\\python\\python37\\lib\\site-packages\\sklearn\\linear_model\\stochastic_gradient.py:128: FutureWarning: max_iter and tol parameters have been added in <class 'sklearn.linear_model.stochastic_gradient.SGDClassifier'> in 0.19. If both are left unset, they default to max_iter=5 and tol=None. If tol is not None, max_iter defaults to max_iter=1000. From 0.21, default max_iter will be 1000, and default tol will be 1e-3.\n",
      "  \"and default tol will be 1e-3.\" % type(self), FutureWarning)\n",
      "c:\\users\\tians\\appdata\\local\\programs\\python\\python37\\lib\\site-packages\\sklearn\\linear_model\\stochastic_gradient.py:128: FutureWarning: max_iter and tol parameters have been added in <class 'sklearn.linear_model.stochastic_gradient.SGDClassifier'> in 0.19. If both are left unset, they default to max_iter=5 and tol=None. If tol is not None, max_iter defaults to max_iter=1000. From 0.21, default max_iter will be 1000, and default tol will be 1e-3.\n",
      "  \"and default tol will be 1e-3.\" % type(self), FutureWarning)\n",
      "c:\\users\\tians\\appdata\\local\\programs\\python\\python37\\lib\\site-packages\\sklearn\\linear_model\\stochastic_gradient.py:128: FutureWarning: max_iter and tol parameters have been added in <class 'sklearn.linear_model.stochastic_gradient.SGDClassifier'> in 0.19. If both are left unset, they default to max_iter=5 and tol=None. If tol is not None, max_iter defaults to max_iter=1000. From 0.21, default max_iter will be 1000, and default tol will be 1e-3.\n",
      "  \"and default tol will be 1e-3.\" % type(self), FutureWarning)\n"
     ]
    }
   ],
   "source": [
    "# 评估分类器性能的更好方法是混淆矩阵\n",
    "# A类别实例被分为B类别的次数\n",
    "# 想要知道分类器将数字3和数字5混淆多少次，通过混淆军阵的5行3列，这指的是多分类器，而不是所说的二元分类去\n",
    "\n",
    "from sklearn.model_selection import cross_val_predict # 与cross_val_score一样，只不过得到的是预测结果 而不是分数\n",
    "# 用交叉验证得到预测值 y_train_pred\n",
    "y_train_pred = cross_val_predict(sgd_cif,X_train,y_train_5,cv=3) # 参数设scoreing"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 与cross_val_score相比\n",
    "    * 同样执行交叉验证\n",
    "    * 返回的不是评估分数，是每个折叠的预测\n",
    "    * 每一个实例在模型预测时使用的数据，在训练期间从未见过"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[53811,   768],\n",
       "       [ 1626,  3795]], dtype=int64)"
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 得到混淆矩阵\n",
    "from sklearn.metrics import confusion_matrix\n",
    "confusion_matrix(y_train_5, y_train_pred) # 两个参数，真实标签与预测标签\n",
    "# 由于是二维分类器，所以是2行2列，如果是多分类 就有几维"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 行表示实际类别，列表示预测类别\n",
    "# 第一行 第一列 53426 被正确的分为 非5，真负类\n",
    "# 第一行 第二列 1153 被错误的分为 5，假正类\n",
    "# 第二行 第一列 1513 被错误的分为 非5，假负类\n",
    "# 第二行 第二列 3908 被正确的分为 5，真正类\n",
    "# 这种衡量方式太复杂，我们可以用更简单的指标"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[54579,     0],\n",
       "       [    0,  5421]], dtype=int64)"
      ]
     },
     "execution_count": 32,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "y_train_perfect_predictions = y_train_5\n",
    "confusion_matrix(y_train_5,y_train_perfect_predictions)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 正类预测的准确率 被分为分类器的精度"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "$\n",
    "\\text{精度} = \\cfrac{TP}{TP + FP}\n",
    "$\n",
    "\n",
    "TP是真正类的数量，FP是假正类的数量\n",
    "\n",
    "$\n",
    "\\text{召回率TPR} = \\cfrac{TP}{TP + FN}\n",
    "$\n",
    "* 检测正类实例的比例"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 精度和召回率"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.831689677843524"
      ]
     },
     "execution_count": 33,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from sklearn.metrics import precision_score,recall_score\n",
    "precision_score(y_train_5,y_train_pred)  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.7000553403431101"
      ]
     },
     "execution_count": 34,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "recall_score(y_train_5,y_train_pred)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 说明检测一张图的时候，只有77%的概率是准确的，而且只有80%的数字5被检测出来\n",
    "# 精度和召回率合成单一指标。成为F1分数，谐波平均值\n",
    "# 平均值平等对待所有的值，谐波平均值给予较低值较高的权重，只有召回率和精度都很高时，才能获得较高的F1分数"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "$\n",
    "F_1 = \\cfrac{2}{\\cfrac{1}{\\text{precision}} + \\cfrac{1}{\\text{recall}}} = 2 \\times \\cfrac{\\text{precision}\\, \\times \\, \\text{recall}}{\\text{precision}\\, + \\, \\text{recall}} = \\cfrac{TP}{TP + \\cfrac{FN + FP}{2}}\n",
    "$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.7602163461538461"
      ]
     },
     "execution_count": 36,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from sklearn.metrics import f1_score\n",
    "f1_score(y_train_5,y_train_pred)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [],
   "source": [
    "# F1分数对那些具有相近精度和召回率，分类器更有利，这不一定适合自己的预期\n",
    "# 有时你更关心精度，有时你能关心召回率\n",
    "# 训练一个分类器检测儿童可以放心观看的视频，你可能要求拦截了很多好的视频，低召回率，保留下来的都是安全的视频，高精度\n",
    "# 不能同时增加精度并减少召回率，反之亦然\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 精度/召回率权衡\n",
    "* SGDClassifier对每个实例基于决策函数计算一个分值，大于阀值为正类，否则为负类\n",
    "* 中间阀值右侧找到4个真正类 真5 ， 一个假正类 6， 精度为 4/5 80%\n",
    "* 在所有的6个 真正的5 中，分类器找到了4个，召回率为 4/6 67%\n",
    "* 提高阀值，向右移动，精度提高，召回降低\n",
    "* 反之阀值降低，召回提高，精度降低\n",
    "* SKlearn不可以直接设置阀值，可以访问决策分数，\n",
    "* SGDClassifier 默认阀值为0 "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 如何设置阈值\n",
    "# 用predict_proba得到每个实例属于正类的概率，然后对概率切一下，以LogisticRegression为例\n",
    "# clf = LogisticRegression()\n",
    "# clf.fit(X_train,y_train)\n",
    "# pred_proda = clf.pred_proda(X_test)[:,1]\n",
    "# threshold = 0.75  # 阈值设置为0.75\n",
    "# pred_label = pred_proda > threshold\n",
    "\n",
    "# pred_proda是每个实例为真的概率\n",
    "# 假设阈值是0.75\n",
    "# pred_label里True十九概率大于0.75的"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([222757.5043904])"
      ]
     },
     "execution_count": 39,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 返回决策值decision_function\n",
    "y_scores = sgd_cif.decision_function([some_digit])\n",
    "y_scores"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ True])"
      ]
     },
     "execution_count": 40,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "threshold = 0\n",
    "y_some_digit_pred = (y_scores >threshold)\n",
    "y_some_digit_pred"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ True])"
      ]
     },
     "execution_count": 41,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 提高阈值可以降低召回率，提高阈值到200000，就错了这个图\n",
    "threshold = 200000\n",
    "y_some_digit_pred = (y_scores >threshold)\n",
    "y_some_digit_pred"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "c:\\users\\tians\\appdata\\local\\programs\\python\\python37\\lib\\site-packages\\sklearn\\linear_model\\stochastic_gradient.py:128: FutureWarning: max_iter and tol parameters have been added in <class 'sklearn.linear_model.stochastic_gradient.SGDClassifier'> in 0.19. If both are left unset, they default to max_iter=5 and tol=None. If tol is not None, max_iter defaults to max_iter=1000. From 0.21, default max_iter will be 1000, and default tol will be 1e-3.\n",
      "  \"and default tol will be 1e-3.\" % type(self), FutureWarning)\n",
      "c:\\users\\tians\\appdata\\local\\programs\\python\\python37\\lib\\site-packages\\sklearn\\linear_model\\stochastic_gradient.py:128: FutureWarning: max_iter and tol parameters have been added in <class 'sklearn.linear_model.stochastic_gradient.SGDClassifier'> in 0.19. If both are left unset, they default to max_iter=5 and tol=None. If tol is not None, max_iter defaults to max_iter=1000. From 0.21, default max_iter will be 1000, and default tol will be 1e-3.\n",
      "  \"and default tol will be 1e-3.\" % type(self), FutureWarning)\n",
      "c:\\users\\tians\\appdata\\local\\programs\\python\\python37\\lib\\site-packages\\sklearn\\linear_model\\stochastic_gradient.py:128: FutureWarning: max_iter and tol parameters have been added in <class 'sklearn.linear_model.stochastic_gradient.SGDClassifier'> in 0.19. If both are left unset, they default to max_iter=5 and tol=None. If tol is not None, max_iter defaults to max_iter=1000. From 0.21, default max_iter will be 1000, and default tol will be 1e-3.\n",
      "  \"and default tol will be 1e-3.\" % type(self), FutureWarning)\n"
     ]
    }
   ],
   "source": [
    "# 如何决定使用什么阈值\n",
    "# 返回决策值，而不是预测结果\n",
    "y_scores = cross_val_predict(sgd_cif,X_train,y_train_5,cv=3,\n",
    "                            method='decision_function')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(60000,)"
      ]
     },
     "execution_count": 43,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 有了y_scores，可以计算所有可能的阈值精度和召回率\n",
    "y_scores.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.metrics import precision_recall_curve\n",
    "precisions,recalls,thresholds = precision_recall_curve(y_train_5,y_scores)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAeMAAAEPCAYAAABx8azBAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjAsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy8GearUAAAgAElEQVR4nOzdd3hUVf7H8feZyaQ30iCEAKH3GqqKioWm6K4NFMUCqIi66qqrPyy7FnRBRVTEYEFEZbGCiqKiIiAtKKD00GsakF5mJuf3x0lIgAABktxJ8n09zzy5c+fMzHdC+cy599xzlNYaIYQQQljHZnUBQgghRF0nYSyEEEJYTMJYCCGEsJiEsRBCCGExCWMhhBDCYhLGQgghhMVOG8ZKqXeVUilKqb9O8rhSSk1RSiUppdYppbpVfplCCCFE7VWRnvEMYOApHh8EtCy+jQHePPeyhBBCiLrjtGGstf4VOHSKJlcBM7WxHAhVSkVXVoFCCCFEbedVCa8RA+wpc39v8b4DxzdUSo3B9J4JCAjo3qZNm0p4eyGEEKL6HToEu3dDmzbg62v2/fknFBaW375+fUhOXp2mtY48/rHKCGNVzr5y59jUWicACQB+DVvpwiuew2G34WVX+Drs+DnsR+/7eNnwddixKYUClFLYFOZ+OT/tShHi7yDI14Gfw35MW7tNYSt+vlLmveoH+1A/2JcQPwfedhsOLxt+Djt2W3kfRwghhDjWlClw//1w8cXw2mtm35dfQnZ2+e3btYPu3dWu8h6rjDDeC8SWud8I2H+6JxVpTWa+qxLevvJ42RT1ArwJ9XPg47DhsJuALgltHy8bft52/L1LvjTYCPb1IiLQ5+g+h92Gt5eNAO+yXyzseHvJwHUhhOdyOsHhsLqK6pWfD+vWQcuWUK/emT33//4Pnn/ebIeFle6/+uqzq6UywngeME4pNRvoBWRorU84RH289g2D+fnJy3EWFeFya3IKXRQ4i3C6i3AVFZFT4MZdpCnSmiIN+viflL2vcbo1mXlODucW4irSaA1FRRq3Lt4ubucugpwCFylZ+aRkFpBV4MLpLiLf6SbfWURqVgGpWQWV8Gs5VoC3nSBfx9HQ9vayEeznhZ+jdH+AjxcxoX4E+Hhht4HdZsPLZo4SRAb50CQ8gGBfL5SS3rsQNUlBAaxaBVu3mu2iIggPh8hIiIoyYeDjY9rm5MCvv5reVb160LixuZUcBi1x332mNxYUZA5/hoaa28iRMGIE7N0Ld98NNpt5nd9+M68RHAwhITBkCIwda16rVy9YuRICAkxd4eEmYMLDYeBAuO020y47G/74A6KjYcUKOHAAWrSA2Fho0gQiIqrvd1oZnnwSJk6Ejz+GYcPMvl9/hfXroVMn6NjR/L7KM2FC6Xbr1udey2nDWCn1MXAREKGU2gs8BTgAtNbTgPnAYCAJyAVuq8gb24oPK3uSnAIXGXlOMvKcuNyaQncR2QUuDmbkkVPgpsBVRFa+k0KX+dJQ6NZk5BWSnl1IvtON061xFRWRW2iC3ekuwuUuItfpJqfQ3M6V3aYI8vU6ekjdYbfh42UjItAHP287kUE+NAzxxddhp0VUIHERAYT6ex/9EiCEqFo//miCLiICfv4ZWrWC8eNh0qSTP2fDBmjb1mwHBpbfpkEDWLDAhMT06aWHRbOyzK1E//7mZ36+OXz6+OPmC8Dx4uJKt6+4woRxTo657d5d+lhERGkYb9gA/fqVX19cHGzfXnq/pOfYoAE0bw6NGpnQ7t69NPhKFg08Xf9i6VKYP9+8R6tW5la//umfdzKpqTB8OCxcaO5nZpY+Nns2vFnmmqB69UwgBwdDjx7wzjtmv58f5ObC11+bLyznSlm1hGJ8fLxOTEy05L2rm7vI9Pwzcp0UFAd5ntNNdr6LPKebjDwnBU43mfku9h7Oo8Bljgq4ijTu4qMGqVkF7EzPId9ZdNZ1+HjZCPJ1EOrvoEGwrwloLxvedhv1/L2JCPImzN+b6FA/Gob4EuLvINjXga/DXom/DSFqhpwcmDrV9GIDAsxt40YTAFrDf/9r2q1YAb17m+3wcEhPL32N2bPhhhvM9osvmv/IIyJMbzI314RCaiosXmyeC6bXefCg6Zl26GCCcc8ecLthxw5o2tTUZC/+Z/ntt9CsGRw5AocPm+Br0cI8tmeP6ZHv3296tV26mM+RkWHCsUsX027LFnOIuqT+Q4fMz5QU89p9+5p2q1fDuHHm9XbvNr+LwYPN+zRtCnPnmna5ueZ9yjN4MHzzjdlOSzM96uhoE9qxsSZozzvPhG2zZubLia2cfoSvLzRsaL6YlHwB2bzZ/O46djQhOngwLFsGTzwBDz1k2iQlwTXXmMPTYOrcv7+0Bzxnjvmdrltneshlv8hccon5sgXwyivmS1ZKysk/a3mUUqu11vEn7JcwrlkKXUUcySvE6TZB7Swq4lBOITkFLvKdRew9nMuhHNNb33Agk0M5hRzJLSTP6aboLP6olYLYev60iAqkSbg/wb4OYkL9aBBiwjymnh+RgT54Sa9b1CAbNpggKCyE5GTTy1mxwvzHf/fdJjB37zZBUZ5GjUwwenmZACjvwpBu3cxgntjYEx87lfJ6iy6XOSTcsGFpCKenlwa4p8nOhtdfh7VrTUgPGGAOm+/ebe7feKNpt2YNdO168teZMcMcdp8715yLHTLE/Llt2WK+eAAsWWLCG+CBB2DyZLPtcJjz4GCOIowbZ7ZnzYKbbzbbPXvCe++ZgVXlcbvNF5fMzNL3K6l39WpT13/+c2a/GwnjOk5rbQ6VF7hIzy4kOTOfApebQremwOnmcG4hKZkFHMzM52BGPgcz88l3uknLPskY/eNEBPrQqn4gPZqG0bpBEE3DA2gWGSC9amG5/ftNb6iktwSm91j2kGpZf/0F7dubQ7/BwabX9re/mZ7y/v1mf58+8NxzJsQPHza9qfPOM+dswYS1qJjMTPNF48AB2LXL9ORLeqQ//2zOpa9caXrH8WUiLCvL/HnExoK/v9n32GMmbA8dMr1zMF+o1q0r7fn+9psJ+aIic9438oSLjKpWjQzjjIwM0tLSKDzZRVuiyuniwXGuoiLcRWYgnMutzcA5TO/cDKg7kQJzGNzLho/dho/Dhq0CJ3m8vb2JiIggJCSk0j+PqP20NoE6dao5x7pjh+ll/vCDOcwIJkyzs83hxdWrzQAct9sMpEpIMIdMRc2ltQn2kp73yY5wWOFkYVwZo6mrRH5+PsnJyTRq1Ag/Pz8ZQezBTGAXkVPoJq/QDHQrdLkpdGl0mZguUgofhx0/b3NNuY+XDYdd4WUvDWmtNXl5eezduxcfHx98jx9CKsRxDhww51d9fODBB825vON17w4zZ5aG8bJl1VujqF5KmcPhTZtaXUnFeWwYp6amEhkZiX/J8QfhsZRSeHvZ8fayU6/MH5fLbUaW5xa6ycp3kud0k1voIrfQdcLz/Rx2vO3mdfy9HYSGhZOamkrsmZ5wE7We02kGPE2bBp99Zg435uSY/Q0bHtu2d28z2tVTz60KUcJjwzg/P58GcqyoRvOy2wj2sxHs56BBiK/pPRe4KHSZ0eROdxFOt+lV5xa6MKd4zIgL7dbs3ZPK0wsPMqRTNPFNwmgQ4iuTp9RRTqcZgfuPf5jDj8dbuhQuu8yMmG3XDs4//+TXhwrhiTw2jF0uF15eHlueOAsOu41Qf+8T9ruKJ11xujV5TrfpQReAwwYLN6WwcFNK8fMV7aKD6dUsnFb1g4iL8Kd9wxAZJFaLaW0OOTqdZgR02SBu0cJMfHH77aWXlpRcaiNETePRaSfniesGL7uNwOJLo0pmpCvSGn3Eh6evbMe3fx1kR1oOKVkFrN2bwdq9Gcc8v0m4Py2jgji/RTjXxccS4OPRf63FKeTkmAFUP/5oBt/s329GxtarZw5BP/20OS8cFGR1pUJULo8dTb1x40balkxJI+qk4/8OpGUXsHrXYdbuOcK21Gw2HMhk/5F83GUuoA729aJnXDiDOzZgQPsGEsw1wJEjpof78cfmetrjlZ2dSoiarsaNphbieBGBPgxob0K2RKGriB1pOSzblsaHK3azNSWbHzcm8+PGZGAt57eIoEVUINEhvjSq588lbaPksLYHWLrUjHSNiTHX5q5ZUxrEQUFmysc33jAjpEtmkxKiNpPRMNVoxowZKKWO3oKCgujcuTOvv/46rvK6BFVg586dKKWYMWNGhZ9TUvfOnTurrK6z5e1lo3WDIG49L47vH+jHTw9dyPghbWkXbUbvLElKY8ZvO5nw7Sbu+eh3zn/xJ974OYnsAs9aMawuSE2Fl182E2Wcf76Zn/jIERPC111nZmdyu80kEEuWQOfOZmYrGToi6gL5a26BTz75hEaNGpGZmcknn3zCvffeS0pKCv8503nVzkJ0dDTLli2jefPmFX7OkCFDWLZsGdHR0VVY2blTStEsMpBmkYGMuqAZew7l8te+DHYfyiU5s4DFW1PZmpLNxAWbmfT9ZnrHhdOrWRg9m4bRq1m4rGVdRU42T/GSJWZWJS8vM3ewEHWZhLEFunTpQoviY2+XX345SUlJTJ48udwwdjqdeHlV3rKJPj4+9C6Z1b6CIiMjiazuOeMqQWyYP7FhpRc+F7jcfPfXQd5ZsoO/9mWwbHs6y7abWf2bhvvzr0FtuLhNFD5echi7smRklD9vc0pK9U9DKIQnk8PUHqBHjx5kZWWxcuVKlFJMnTqVRx55hIYNG+Lj48ORI0cA+Pzzz+nduzf+/v6EhoZy3XXXsbvsWmfFpk+fTrdu3fDz86NevXpceOGF/Pbbb0D5h6lXrVrFZZddRnh4OP7+/jRr1oyxJQudUv5haqfTyfjx42natCne3t40bdqU8ePH4yyZmb3Me7311ls8+eSTREdHExoaypVXXsnevXsr+bd4ej5edq7qEsO8cefz+xOXMem6ztzatyn1g33YmZ7LXbN+55KXFrFoSypWDWys6YqKzET9PXua+8HBpZPwP/20uVRJawliIY5XI8NYqZPfEhJK2yUknLptWd27n7zdmDGl7VavrvzPs2PHDux2O4HFC5k+99xzbNmyhYSEBL744gt8fX2ZNm0a11xzDe3atePTTz/lrbfe4q+//uLCCy8kq8xipv/85z8ZM2YM3bp1Y86cOcyaNYt+/fqVG9oA2dnZDBgwALvdzowZM5g/fz5PPvnkac9hjxw5khdeeIFbbrmFr7/+mttuu40XX3yRkSNHntB2woQJJCUl8e677/Lqq6+ybNkybrrppnP4jZ27UH9vru3eiKeHtmfRwxfzz8tbERPqx97DeYx8dyXxz/7Ii99t4mBGvqV11hRam9V17Hazcs6aNeamFHz4oTkv/NRTVlcphAfTWlty6969uz6VDRs2nPSx0u/XJ97eequ03VtvnbptWd26nbzd6NGl7RITT1n2Kb333nsa0Js2bdJOp1MfOnRIT5s2TdtsNn3VVVfpHTt2aEB37dpVFxUVHX1eVlaWDg4O1rfddtsxr7djxw7tcDj0K6+8orXWeuvWrdpms+kHHnjgpDWUvMd7772ntdZ61apVGtBr1649bd07duzQWmv9559/akA/9dRTx7R75plnjnmtkvfq16/fMe0mTpyoAb1v375T/r5O9XegKuQVuvSE+Rt1538v0E0e/Vo3efRr3Wb8t/rRT9fqGUt36N3pOdVaT01QVKT1d99pHR5+7L+ZJk20Tk21ujohPA+QqMvJxBrZMz5VxJbtxY4Zc+q2Za1effJ2ZXvb3bufe/1t2rTB4XAQFhbG2LFjuemmm3j33XePPn711Vcfc4542bJlZGZmctNNN+FyuY7eGjVqRJs2bfj1118B+PHHHykqKmJM2V/CabRs2ZLQ0FDuvPNOZs2axZ49e077nJL3GzFixDH7S+4vWrTomP1Dhgw55n7Hjh0BTtpbt4qvw86/BrXh9/GXMefOPvRpFk6e083sVXt4at56Lpr0C8/P30hqVsHpX6yO+P57GDXKrK0L5nphtxt27jRrAgshKqZGhnFN98UXX7Bq1So2bdpETk4OM2fOJCws7Ojjx49aTkkx00FeeumlOByOY25//vkn6cX/E5b8bHQGi6mGhITw888/07BhQ8aOHUvjxo3p0KEDn3322Umfc+jQoXLrLJlLvOTxEmU/G5hBZGDmH/dENpuiZ1wYH43uxewxvXl4QGsubBWJu0iT8Ot2+k/6hVd/3EpOHbw8avt2WLjQbBcUmLVjs7LMnNGbNsGrr5oR0kKIMyOjqS3QoUOHo6Opy3P8yOnw4iVnZsyYQfv27U9oH1Q8N2BEcVdk3759tG7dusL1dOnShc8++wyXy0ViYiITJkzg+uuvZ+3atXTo0OGE9iXhevDgwWMukTp48OAx9dZ0Sil6Nwund7Nw7rkYfktK49WFW1mx4xCv/LiF937bwb39WzKid+NaPwI7KQlGj4ZffoHoaNPz9fGBf/8bpkwx01UKIc6efIetAfr27UtQUBBJSUnEx8efcCsJ3ksvvRSbzUZC2ePqZ8DLy4vevXvzzDPPUFRUxMaNG8ttd+GFFwIwe/bsY/Z/+OGHAPTr1++s3t/T9W0RwewxvZk2ohvNIgM4kuvkma83cPHEX1hefIlUbfTyy9CypQliMLNmFQ/wp1kzCWIhKoP0jGuA4OBgJk6cyD333ENqaiqDBg0iJCSEffv2sWjRIi666CJuvPFGmjdvzgMPPMDLL79MVlYWQ4cOxW63s3LlStq0acMNN9xwwmt//fXXJCQkcPXVVxMXF0dOTg5TpkwhKCiIPn36lFtP+/btGT58OE8//TQul4u+ffuybNkynnnmGYYPH06nTp2q+ldiGaUUAztEc3m7Bny1bj8vfruJ/Rn5DEtYzqAODXjhmk6E+DmsLrNSaA1vvmmWJSwxbhy89pp1NQlRW0kY1xB33nknsbGxTJw4kY8++gin00lMTAz9+vWjS5cuR9tNmjSJFi1aMHXqVN5//30CAgLo1KkTl19+ebmv27JlS/z8/HjmmWc4cOAAQUFB9OjRgx9++OGU557ff/99mjVrxrvvvsuzzz5Lw4YNefTRR3mqjly/YrMpruoSw4D2DXjp+81MX7yDb/86yLq9Gbx3Ww9a1a/5ywp9/jncc0/pfadTpqYUoqrIqk3CY9WkvwMrdxzi4U/Xsis9lyAfL6aPjKd3s5p97ryoyMwffc01UM5BFSHEWTjZqk1yzliIStAzLoxv77+A3s3CyCpwcet7K5m2aBsFLrfVpZ2R2bNh5kyzbbPBnDkSxEJUBwljISqJv7cXM2/vxZWdG5LvLOKFbzcxcPJi/tqXYXVpFZKYCCNGmJm0Nm2yuhoh6hYJYyEqkbeXjdeGd2XaiO5Eh/iyIy2Hq95YyoT5GzmcU2h1eeXSGl55BXr0MBN2/P3vcAZXxgkhKoGEsRBVYGCHBnz/QD+Gdm6Iu0jz1q/b6f/SL7y7ZAcud5HV5R1jwAB48EGzHRUFH3xw4tztQoiqJWEsRBUJ8nXw6rAuvHtrPJ0ahXA418l/vt7AhRN/4eOVuy1fGUpr6N0bfvjB3J88GZKTwd//1M8TQlQ+CWMhqpBSiv5t6vPZ3X2ZMrwrMaF+7DuSx2Of/8n0xdstrg3i4sz2tdfC/fdbWo4QdZqEsRDVwGG3MbRzQxY9fBGPDDQnZCd8u4m5a/ZVax1awzffwJYt5tKl/v3NYg+ffFKtZQghjiNhLEQ18rLbGHtRCx64tBVaw/2z15Dw67ZqO2Q9bhxccQUUFppLl0aPhssuq5a3FkKcgoSxEBa475IWjOjdGIDn529i9MxE3EVVG8ivvw5Tp5rtlSur9K2EEGdIwlgICyilePbqjkwZ3pUAbzs/bkzhzg8Sycx3Vsn7DRoE995rth98EG6/vUreRghxliSMq9GMGTNQSh29eXt707x5cx5//HFL1/a99dZbadq06dH7O3fuRCnFjBkzLKuprhjauSHTb4nHvziQ+09axG/b0ir1PRIS4LvvzPaDD8KkSZX68kKISiBhbIFPPvmEZcuW8c033zBgwAAmTJjAww8/bHVZwiJ9W0Qwb9x5tI0OJi27gBunr2D+nwcq5bV/+w3uvNNsn3cevPSSXEMshCeqUBgrpQYqpTYrpZKUUv8q5/EQpdRXSqm1Sqn1SqnbKr/U2qNLly707t2byy67jKlTp3LppZfyzjvvUFTkWZNBiOrTIiqIufecx9+7xQAw9sPfeen7zec8t3XnztChA3TtCj//XBmVCiGqwmnDWCllB94ABgHtgOFKqXbHNbsH2KC17gxcBLyklPKu5FprrW7dupGXl0damjk8mZuby6OPPkpcXBze3t7ExcXx3HPPnRDWqampjB07ltjYWHx8fIiNjeXmm2+moKAAgKSkJG6++Wbi4uLw8/OjWbNm3H333Rw+fLjaP6M4PW8vGy9d15mRfZoA8NpPSdw+Y9VZTaOZmmp+BgTA4sWwejU4ascyy0LUShVZnbQnkKS13g6glJoNXAVsKNNGA0FKKQUEAocAVyXXCkDTf31TFS97xna+MKTyXmvnTkJCQggPD8flcjFgwAA2bNjAE088QceOHVm+fDnPPPMMhw4d4qWXXgLg8OHD9O3bl0OHDjF+/Hg6depESkoKc+fOpbCwEB8fH/bv30+jRo2YPHky9erVY/v27Tz//PMMHjyYZcuWVVr9ovIopXh6aHs6x4by1Lz1LE1KZ8iUxbxzaw/aRgdX6DUeegheftlcR6wUhIZWcdFCiHNWkTCOAfaUub8X6HVcm9eBecB+IAi4QWt9wjFXpdQYYAxA48aNz6beWsHtduNyucjKyuKLL77gs88+Y/Lkydjtdj744AOWLFnCokWL6NevHwCXXHIJAP/+97959NFHiYqK4pVXXmH79u0kJibStWvXo689fPjwo9v9+vU7+hoAffv2pUWLFlxwwQX88ccfxzxPeA6lFH/v1ogOMSHc9/EfbDqYxYi3V/DU0PYM7dzwlM+dPNkEMcBXX8HQodVQsBDinFUkjMsb7nH8BZEDgDVAf6A58INSarHWOvOYJ2mdACQAxMfHn9VFlZXZI7VKmzZtjrk/duxYxo0bB8B3331HkyZN6Nu3Ly5X6cGFyy+/nPHjx7N8+XKGDh3K999/T48ePU4ZqIWFhUyaNImZM2eya9euY0Zsb968WcLYw7WqH8Rnd/fl1vdWsmrnYe77+A9SMvMZdUGzctt//TU88EDp/UGDqqlQIcQ5q8gArr1AbJn7jTA94LJuAz7XRhKwA2iDKNcXX3zBqlWrmD9/PpdeeilTp05lZvGK7ikpKezatQuHw3HMrWfPngCkp6cf/dmoUaNTvs9jjz3G008/zYgRI/jmm29YuXIln3/+OYCll1KJigvw8eKj0b156LJWADw/fyN/7D7xnH9yMtx4o9lu2tQcopZzxELUHBXpGa8CWiql4oB9wDDgxuPa7AYuARYrpeoDrQFrZ8H3YB06dKBFixYA9O/fn06dOvHwww9zzTXXEB4eTlxcHHPmzCn3uSXXA0dERLBv36nnNZ49eza33HIL48ePP7ovOzu7cj6EqDYOu417L2nJ/ox8Pl65m1vfW8WcO/vQukEQYKa2HDQIsrLg/PPhl1/k8iUhaprT9oy11i5gHLAA2AjM0VqvV0rdpZS6q7jZM0BfpdSfwELgUa115c5cUEv5+PgwceJEUlJSmDp1KgMHDmTPnj0EBgYSHx9/wi0iIgIwh61XrlzJ2rVrT/raubm5OI7rHr333ntV+nlE1XniirZ0iAkmI8/JNW/+xgfLd6G1ZvVqs/BDZCT8739gt1tdqRDiTFWkZ4zWej4w/7h908ps7wcur9zS6o6hQ4fSo0cPJk2aRFJSEu+99x6XXHIJDz30EJ07d6awsJBt27Yxb948vvzyS/z9/XnggQf46KOPuPTSSxk/fjwdO3YkLS2NuXPnMm3aNIKCghg4cCDvv/8+HTt2pEWLFnz++ef89ttvVn9ccZb8vb3435g+jHo/kWXb03niy7/YlpLNE1e0Y/ZshcsFDU89vksI4aEqFMai6j377LMMGDCAt99+mwULFvDCCy+QkJDAjh07CAgIoHnz5gwZMgRvb3P5dmhoKEuXLmX8+PG88MILpKenU79+ffr373+0zWuvvYbWmv/7v/8DYPDgwXz88cdHzz+LmifAx4tZo3rx7pIdvPDtJmb8tpOcAhcvXtMJm02OTQtRU6nqWrrtePHx8ToxMfGkj2/cuJG2bdtWY0XC08jfgZNbtgz6D08jZngiLu3mlj5NePrK9hLIQng4pdRqrXX88ftlbmohapjDh2HYMMjfFUHwmni87TZmLtvFf77ecPonCyE8koSxEDVIVhb06AG7d0PPnrB8bgRThpvrxWf8tpNhCctwumWOcyFqGgljIWqQ88+HbdsgOBg+/hi8vWFghwY8daWZLn759kPc9/EfFBVZc/pJCHF2JIyFqCHuuAPWrTPbX34JzcpMxHXbeXHMuqMXQT5efPvXQV7+YYs1RQohzopHh7FVg8uE9eTP/liFhfDFF2b7kUfg4otPbHN+ywimjuiGTcHrPyexZKtc6i9ETeGxYexwOMjLy7O6DGGRvLy8EyYsqcscDrjlFrjiCnjhhZO3u6BlJHdf1ByA+2f/wcEMmfZUiJrAY8M4KiqKffv2kZubK72kOkRrTW5uLvv27SMqKsrqcjyGUmZFpq++Ov1Ul/df0oq+zcNJzylk+PTlbE+VKVCF8HQeO+lHcLBZu3X//v04nU6LqxHVyeFwUL9+/aN/B+q6mTOhe3do375i7b29bLx+Yzeuf2sZSSnZ3DVrNV/dez4+XjJPphCeymPDGEwgy3/Ioi776CMYOdKMmt6yBZo0qdjzwgK8+fKe87jytSVsSc4mYdF27r2kZdUWK4Q4ax57mFqIum7jRhgzxmy/+mrFg7hEoI8Xz1zVAYDpi7ezauehSq5QCFFZJIyF8EDZ2XDttZCTAzfdBHfeeXavc16LcC5oGUFmvovRMxNJyy6o3EKFEJVCwlgID6O16RFv2ABt28K0aWe/PrFSindG9qBPs3CO5Dq558PfyXe6K7dgIcQ5kzAWwsNMn25m14TQa6kAACAASURBVPL3h08+gcDAc3s9by8br9zQhcggH1bsOMSdH6ymwCWBLIQnkTAWwsMEBUFAACQkVHwE9ek0CPHlw1G9CA/wZtGWVO6e9bsEshAeRMJYCA8zfDhs3WrOFVemVvWDmDWqF/X8Hfy0KYXbZ6zCLXNYC+ERJIyF8BCHD5duR0dXzXu0jQ7mgzt64euwsTQpnbEfrqbQJas8CWE1CWMhPMCmTebSpaefNgO4qlKHmBCmjeiOt5eNBeuTeXDOGhnUJYTFJIyFsJjbDbffbtYq3rPn7EdOn4mLWkfx0aheOOyKr9cdYFjCcnILXVX/xkKIckkYC2GxBg1g2TIIC4OXXqq+941vGsbsMX1oEOzLmj1HeGjOWlkHWQiLSBgLYaEtWyCteKXDN9+E0NDqff/uTerxwR09j66DPPH7zdVbgBACkDAWwjJam7WJS1x/vTV1tKwfxNQR3bDbFG/+so03fk6yphAh6jAJYyEssngxzJ1rJvfYts3aWi5oGcmEv3UEYOKCzXy2eq+1BQlRx3j0qk1C1GYXXAB33w19+kCzZlZXA9f3iCUjz8lz8zfy8KdrcXjZGNq5odVlCVEnSM9YCIsoBa+/DjffbHUlpUb3a8bwnrEUafj3vPVk5cta4kJUBwljIarZW2/BH3+YbZsH/gt89uqOdI4NJT2nkGe/3mh1OULUCR74X4EQtdf69TBuHPTqBfv2WV1N+ew2xcRrO+HtZeN/iXv48g8PLVSIWkTCWIhq1LkzuFwwahTExFhdzcm1qh/EE0PaAvDIp+tYs+eIxRUJUbtJGAtRTb7/3sy2BfDcc9bWUhE392nK8J6xFLqLeGjOGjl/LEQVkjAWohqkpcHo0Wb7+eehXj1r66moxwe3pVE9P7al5nDbe6twumVRCSGqgoSxEFVMazP39O7d5lzxgw9aXVHFBfk6+OAOsw5y4q7DvP6TTAgiRFWQMBaiim3cCK1amaku58wBHx+rKzozcREBTBneFYBXF27lzg8SSc8usLgqIWoXCWMhqli7dmaWrZdegsaNra7m7JzXIoL/G2wGdC1Yn8z9s9fIohJCVKIKhbFSaqBSarNSKkkp9a+TtLlIKbVGKbVeKbWocssUomb68084eBD+8x9zqLomG92vGZ+P7Uuov4MlSWnM+G2n1SUJUWucNoyVUnbgDWAQ0A4YrpRqd1ybUGAqMFRr3R64rgpqFaJG+fZbM93lnj1WV1J5ujWuxwt/N3NYv/zDFnal51hckRC1Q0V6xj2BJK31dq11ITAbuOq4NjcCn2utdwNorVMqt0whapasLBg8GJYuhYkTra6mcg1o34DL29Unu8DFbTNWkVfotrokIWq8ioRxDFD2u/3e4n1ltQLqKaV+UUqtVkrdUt4LKaXGKKUSlVKJqampZ1exEDVAyXzT7dvDzJnW1lLZlFJMur4zcREBbE/NYfKPW6wuSYgaryJhrMrZd/zIDS+gOzAEGAA8oZRqdcKTtE7QWsdrreMjIyPPuFghaoI9e8wEHwCPPQa+vtbWUxWCfR28fH1nABIWb+e7vw5aXJEQNVtFwngvEFvmfiNgfzltvtNa52it04Bfgc6VU6IQNct990Fenpnu8qabrK6m6nRtXI+HLmuF1nDfx3+wZGua1SUJUWNVJIxXAS2VUnFKKW9gGDDvuDZzgQuUUl5KKX+gFyDLvYg6JyEBvvwSgoJgxQqrq6l64/q34O/dYih0F3H3rNXsO5JndUlC1EinDWOttQsYByzABOwcrfV6pdRdSqm7ittsBL4D1gErgbe11n9VXdlCeKbcXPDzg2ef9eyFICqLUopJ13amf5sosgpcPDRnjQzoEuIsKK2tuXA/Pj5eJyYmWvLeQlSVzEz4+We44gqw262upvoczMhn4Ku/ciTXSf82UUwb0R1vL5lTSIjjKaVWa63jj98v/1qEqAQlqzEFB8NVV9WtIAZoEOLLnDv7EOLn4KdNKdz78e8yQ5cQZ0DCWIhzpDV4ecFTT4GzDq8y2Kp+EO/f3hN/bzsL1ifz0crdVpckRI0hYSzEOXr7bfPzzTfB5bK2Fqt1iQ1lQvEMXRPmb2RrcpbFFQlRM0gYC3EODh6EfxXP1v7f/5rBW3Xd0M4NuapLQ3IK3Tz2+Z9YNS5FiJpEwliIczB2LBw6BJddBiNHWl2NZ1BK8czVHY6ugbxgfbLVJQnh8SSMhThL334LX3xhril++21Q5c1VV0cF+zq468LmADz+xZ/sl+uPhTglCWMhzoLbDbfdZrYfeaTmrlNcle44P45+rSI5lFPI3bNWU+CS64+FOBkJYyHOwuHD0LOn2b73Xmtr8VQ2m2LyDV2ICfVj7d4Mnvl6g5w/FuIkJIyFOAsRETB3LuzeDSEhVlfjucICvJkyvCvedhuzlu9m2qLtVpckhEeSMBbiDJV07pSC2NhTtxXQvUk9Xh3WBYD/LtjEgvWywpMQx5MwFuIMbNkCXbvCvOOXShGnNKhjNA8PaI3W8I/Za1i/P8PqkoTwKBLGQlSQ1ub88Nq1ZmUmcWbGXtScv3eNIc/pZtT7iaRk5VtdkhAeQ8JYiAr6/HP4/nsIDYUXX7S6mppHKcWEazrSvUk9DmTkM3rmavKdMsJaCJAwFqJCCgvhscfM9nPPQWSktfXUVD5edt66ubsZYb3nCA9/uk5GWAuBhLEQFfLss7B1K7RsCXfcYXU1NVtEoA/v3BpPgLedr9bu57WfkqwuSQjLSRgLcRrr18OECWb09DvvgI+P1RXVfG0aBDNleFeUgpd/2MLbi+WSJ1G3SRgLcRppaVC/PowZAxdcYHU1tcclbevz+KC2ADz7zUYWb021uCIhrCNhLMRpXHghbNxoVmUSlWvUBXGM7NMEgAf+t1YGdIk6S8JYiJMoO64oKAiCg62rpbZSSvHEFe1oFx1MWnYBk3/canVJQlhCwliIk7jjDrMIRE6O1ZXUbl52G89c3QGAt37dxpKtaRZXJET1kzAWohwLF8J778Frr8FBmb2xynVvUo/7LmmJ1vDoZ+vIyHVaXZIQ1UrCWIjj5OXB8OFm+4knoHlza+upK+7t34JOjULYdySPB+eskeuPRZ0iYSzEcR56CFJToV07+Oc/ra6m7nDYbbxxYzeCfL1YuCmFNxdts7okIaqNhLEQZXz3Hbz5ptl+803w9ra2nromNsyfCX/viE3Bf7/bzLy1+60uSYhqIWEsRLGMDBg1ymxPmAD9+llbT111RaeGPD7YXH/86Kfr+HWLXH8saj8JYyGKZWdDr17mJoenrXXH+XFcH9+IPKeb0TMT2XQw0+qShKhSEsZCFIuJgc8+g19+AS8vq6up25RSvPD3TvytawwFriLGzFzN4ZxCq8sSospIGIs678gR2LGj9L6vr3W1iFI2m+L5v3WkY0wIuw/lMuKdFXLJk6i1JIxFnaY19OwJzZrBTz9ZXY04np+3WXIxNsyP9fszuSFhGalZBVaXJUSlkzAWddq8eWZpRIDWra2tRZSvYagf/xvTh7iIADYdzGLE2yvIK5Q5rEXtImEs6qy0NLjzTrM9ebI5Zyw8U8NQPz4c1YuIQB82J2cx4duNVpckRKWSMBZ11j33QHKyWZXp3nutrkacTsNQP6bf0h27TTFz2S5e/mGL1SUJUWkkjEWd9PHHMGcOBASYOaht8i+hRujauB4vX98ZgCkLt7I0SRaVELWD/Bck6pzMTBg71my//DLExVlbjzgzV3WJ4a4LzYTho95P5Lu/DlhckRDnTsJY1DnBwTBzJowcCaNHW12NOBv/vLwVV3SKJs/pZtxHf8iyi6LGq1AYK6UGKqU2K6WSlFL/OkW7Hkopt1Lq2sorUYjKd+WVMGMGKGV1JeJseNltvDa8K7ed1xRXkebej3/nQEae1WUJcdZOG8ZKKTvwBjAIaAcMV0q1O0m7F4EFlV2kEJXhp5/MQhCidlBK8cSQdpzfIoLDuU5GvruSI7kyS5eomSrSM+4JJGmtt2utC4HZwFXltLsX+AxIqcT6hKgUBw+aNYoHDYKFC62uRlQWm03x+o1daRkVyJbkbG6fsQqXu8jqsoQ4YxUJ4xhgT5n7e4v3HaWUigH+Bkw71QsppcYopRKVUompqbISi6gehYVwww2QkgL9+8NFF1ldkahMof7evDOyB952G7/vPsLEBZutLkmIM1aRMC7vrJo+7v5k4FGt9SmnxdFaJ2it47XW8ZGRkRWtUYizprW5hvjXXyE6GmbNArvd6qpEZWsc7s9rN3YFIGHxdr6SdZBFDVORMN4LxJa53wg4/m96PDBbKbUTuBaYqpS6ulIqFOIcvP02JCSAjw/MnWsCWdROA9o34JGBrdEaHpyzhkWyDrKoQSoSxquAlkqpOKWUNzAMmFe2gdY6TmvdVGvdFPgUGKu1/rLSqxXiDPz+O9x3n9mePh169LC2HlH17r6wOXecH4fTrRn3kYywFjXHacNYa+0CxmFGSW8E5mit1yul7lJK3VXVBQpxtjIyIDIS7rgDbr7Z6mpEdVBK8X+D23Jx60iy8l3cNet3ClyyqITwfErr40//Vo/4+HidmJhoyXuLuiMrCxwOWaO4rknPLmDo60vZdySPey5uzsMD2lhdkhAAKKVWa63jj98vM3CJWmf58tLtoCAJ4rooPNCHCX/vCMDbi3ewetdhiysS4tQkjEWt8sor0KcPPPus1ZUIq/VrFcnfu8VQ4CrixunLWbYt3eqShDgpCWNRa3zwATz4oNmWxR8EwLNXd+DydvUpcBVxx/ur2JmWY3VJQpRLwljUCl9+CbfcYrb/+1+46SZr6xGewd/bizdHdKd/myhyC93c+cFqDufIlJnC80gYixpvyRIYNsxs338/PPywtfUIz2K3KSYP60KTcH82J2cxeMpidqfnWl2WEMeQMBY12po1MHgwFBTAmDHmnLEQxwv2dTDrjl50jg3lQEY+N72znA37M60uS4ijJIxFjRYaClFRcP31MHWqLIkoTi42zJ8P7uhJp0Yh7DmUx01vL2f9/gyryxICkDAWNVzTprB0Kbz/vsw5LU4v2NfB/8b04eLWkRzOdXLj9BXskEFdwgNIGIsaJyPDzDldMl9N/fpyLbGoOD9vO9Nu7s5FrSPJyHNy1weryS10WV2WqOMkjEWNkpMDQ4fC6NEwaZLV1YiaysfLzmvDu9I8MoDNyVnc9/Ef5BXKtJnCOhLGosZITTVrEf/6K8TEwHXXWV2RqMmCfB1MGd6VIF8vftyYwuiZieQ7JZCFNSSMRY2we7cZqJWYaCb0WLjQnC8W4ly0bxjCF2P7EhHozZKkNO78YLUEsrCEhLHweFu3QpMmZrtFCzNgq3Vra2sStUeLqCA+Gt2bsABvFm1JZeyHstKTqH4SxsLjlUxxCeYQdXS0dbWI2qlV/SA+HNWLUH8HP21K4V+f/YlVK9qJuknCWHi8d9+Fq682o6gliEVVaRsdzKw7euHvbeeLP/Yx4dtNEsii2kgYC4+jNcydC+7iI4WRkfDFFxAcbG1dovbrEBPCq8O6YrcpEn7dzj8/WYfTXWR1WaIOkDAWHsXlgvvuMz3hf/7T6mpEXXRZu/q8MzIeP4edz37fyz0f/k6hSwJZVC0JY+Ex0tPhqqvg9dfB2xt69LC6IlFXXdQ6io9G9yLI14vvNyRz63srOZIrqz2JqiNhLDzC5s3QqxfMnw9hYfDjj3DjjVZXJeqyro3rMfP2nkQEevPbtnSGvr5UFpcQVUbCWFhu7lzo2RO2bYNu3eD33+GCC6yuSggTyHPHnU+HmGB2H8rlb1OXsmJ7utVliVpIwlhYqqgIpkyBzEy49lpYtKj0mmIhPEFMqB+f3tWXIZ2iKXAVMXpmIhsPSA9ZVC4JY2GJkitGbDb4/HOYPh3mzIHAQGvrEqI8vg47k2/oQv82UWTmu7j2zd+Yk7jH6rJELSJhLKrdnDkwcCA4neZ+SAiMGiVrEQvP5rDbmHpTN67q0pCcQjePfLqO+X8esLosUUtIGItqk5sLY8bADTfA99/DRx9ZXZEQZ8bXYefVYV156LJWADw5dz1bk7MsrkrUBhLGolqsWAFdupjD0T4+MHUq3HKL1VUJcXbuvqg5fZuHk5ZdwMBXFzPh2424i2S2LnH2JIxFlTp0CP7xDzjvPLPgQ/v2sHIl3H23HJYWNZeX3UbCLfEM6xGLu0jz1qLt3D5jlVyLLM6ahLGoUgsXwquvmgFb//gHrFoFnTpZXZUQ5y7Qx4sXrunEzNt7Us/fwaItqVw7bRnp2QVWlyZqIAljUem2bi3dvvZaM73l6tXwyivg52ddXUJUhX6tIvnq3vNpVT+QpJRsbpy+Qi59EmdMwlhUmhUrzJzSbduaCTzAHIp+9VVzvliI2qpRPX9mjepFk3B/NidnMfT1JSzbJpODiIqTMBbnbOtWuPlm6NvXzKblcMBff1ldlRDVKyrIl8/vNpODON2au2atZntqttVliRpCwlicteRkGDcO2rWDWbPMbFpjxkBSklnwQYi6JjzQhynDunJp2ygy8pzc/M5KklLk0idxehLG4qz961/wxhsmhG+/HXbsgLfegpgYqysTwjp2m+LVYV1p3zCYfUfyGPzqEr5ZJ5ODiFOTMBYVlpoKGzaU3n/0URg6FNatg3fegaZNLStNCI8S4OPFR6N6c3m7+hS6i3jgf2tYuDHZ6rKEB5MwFqe1cSPceacJ29tvL51Xuk0bc464fXtLyxPCI4X4O3jr5u6M6N2YQncRo2YmMvWXJKvLEh6qQmGslBqolNqslEpSSv2rnMdvUkqtK779ppTqXPmliupUVATffWd6vu3aQUKCmc4yPByyZUyKEBWilOKpK9tz+3lxaA3//W4zI99dSUpWvtWlCQ9z2jBWStmBN4BBQDtguFKq3XHNdgAXaq07Ac8ACZVdqKg+69ebXu+gQfDVV2b6yrvuMvu/+QaCgqyuUIiaw2G38eSV7Xjlhs4E+nixaEsqg19dzJKtaVaXJjxIRXrGPYEkrfV2rXUhMBs4Zqys1vo3rfXh4rvLgUaVW6aoSkVFx07U0aSJGSnduDE89xzs3g1vvml6yEKIs/O3ro1Y8EA/esWFkZZdyM3vrmDCtxvJKXBZXZrwABUJ4xig7MKde4v3ncwdwLflPaCUGqOUSlRKJaampla8SlEldu6EZ5+FFi2gRw9zGBrMmsK//mom7nj8cYiKsrRMIWqNmFA/Phrdm39c2hKAtxZt57YZqyhwuS2uTFitImFc3nT+5S5PopS6GBPGj5b3uNY6QWsdr7WOj4yMrHiVotIcPgxvvw2XXgrNmsETT5hLkoKDzfXBJTp3Bi8v6+oUoray2xT/uLQV/xvTh6ggH1buOMRdH6wmt1B6yHVZRcJ4LxBb5n4jYP/xjZRSnYC3gau01jIPnAfatw/q14fRo80CDt7eMHw4fPutCWRZwEGI6tMzLozpt8Tj723n582pXPnaElZsl/8666qKhPEqoKVSKk4p5Q0MA+aVbaCUagx8Dtystd5S+WWKM3XwIMyYYWbIKhETAx07ml7xO+/AgQPw0UcwcCDY7ZaVKkSd1Tk2lK/uPZ+4iAC2peZw49sreOPnJFkbuQ5SWp/+D10pNRiYDNiBd7XWzyml7gLQWk9TSr0NXAPsKn6KS2sdf6rXjI+P14mJiedUvCilNfzxB3z9tbmtWlX62Nat5rwwQGGh6RELITxHgcvNKz9sZdois8JKn2bhvHxDZ6JDZJmz2kYptbq8fKxQGFcFCePKs3696e0ePFi6z9cXLrrIzBF9ww1Qr55l5QkhKmjRllQe/N8a0nMKCfL1YkTvJtzbvwX+3jKAo7aQMK4Fjhwxo5x//tksTfjyy2Z/Xp4J2/BwuOIKGDLEhLO/v7X1CiHOXEpWPo999icLN6UAcGnbKN4c0R2HXSZMrA0kjGugQ4fgl19g8WJYsgR+/91cEwxm4o30dLNcIcCuXea6YFXe2HchRI2itWbZtnTumrWazHwXQzpFM/mGLhLItcDJwliOfXiIggJYuxbCwkrP737wAfzjH6VtvLzMmsEXX2xutjL/Lps0qd56hRBVRylF3xYRzLi9J8MSlvPNugOkZRUwbUR36gXIoI/aSHrGFnC7YdMmWLnSDLRatcoEsdMJjzwCL75o2m3YAPfcAxdeCOedB336mAk5hBB1x6qdhxg9M5EjuU4ig3x4bXhXejcLt7oscZakZ2yRwkLYvNmsbFTSkz3vPFix4th2Spn5oMPCSve1a2fODwsh6q4eTcP4eHRvHvl0HX/uy2BYwnKu6BTNpOs64+uQaxJrCwnjSlJYaHq7GzeaHu2mTaX3nU7Yvh3i4kzb9u3NNb49ekDPnuZn9+5mFiwhhDhe2+hgPr27D9N+2c5bv27j63UH2HQwi0nXdaZLbKjV5YlKIIepz0BRkQnRbdtMbzcqylw6BLB6NcSf5Mrq5s3hww+hVy9z3+ksHXglhBBnYktyFmNmJrIzPRdfh43/DO3A9T1iT/9E4RFkNHUFaA1paeYyoZJ5madMgQULzKIKO3aYy4hKDBhg1vwFyMoyYdy6ten5tm1bui3neYUQlanA5eb+j9fw3XozucDfusbw+OC2RAb5WFyZOB05Z1xGerpZp3fPHrM8YMnPXbvMykUbNpgwBVizBubPL31ueLgZ7dyypTn3WyIoyPSWhRCiqvl42Zl2c3dmLd/FU/PW88Uf+/hyzT4ua1ufZ67uQP1gX6tLFGeoVvWMN20y52YPHID9+0tvBw6YSTCef960++svM0dzeUJDYd48uOACc3/FCjOzVdOm5vKhUDk9I4TwIJsOZjJpwRZ+3pyCu0jjbbcxqGMDLm4dxaCODfDxkkFenqTGHqbOyjLTPaamQkqKCcayQbtgQWlADhxo7pfnkkvgxx9LX/Puu80kGbGxpTcJWyFETbX/SB7jv/yLn4pn7gII8XNwfXwjxl3ckhB/GajiCTwujFu2jNcPPZRIaqo5T1v2dsMN5npbMAF62WUnf531680lQABPPgnLl0PDhifeYmPNqkVCCFFbaa3ZlprDT5uS+XT1XrYkZwMQE+rHlOFd6Na4Hkqm6bOUx4Wxv3+8zssrv2c8ahRMn262N22CW26ByEgzejkqyoRqw4YQHQ1du8oczEIIcTytNWv3ZvD453+y4UAmALFhfgzuEM35LSM4v0WEBLMFPC6MGzaM10OGJBIZCRERHP0ZHm4OHzdoYElZQghRqxzJLeSl77fw9br9HM51Ht3fpkEQN/VqzPCejfGSOa+rjceFsSde2iSEELVVgcvN0qQ0EnceZvaqPRzKKQSgcZg/Tw9tR/829S2usG6QMBZCCAGYYJ63Zj8vfreJtGwTyld3acj9l7YiLiLA4upqNwljIYQQxzicU0jC4u28s3gHhW6zPmvHmBCu7xHL9fGN5LKoKiBhLIQQolw70nJ44+ckvl63n3ynCeVgXy8Gd4xmRO8mdIgJsbjC2kPCWAghxCnlFLhYuCmFtxZtY/3+zKP7r+rSkP5toriwVSSh/rKe8rmQMBZCCFFhW5KzePn7LXy/4SBFxTHhbbfRu3k4V3SMZnCnaAJ96uSMyudEwlgIIcQZ252eyzd/HmDRlhRW7jh0NJiDfL0Yd3ELbuzVmCBfmd2roiSMhRBCnJP07AJ+2JDMtEXb2JmeC0CAt53L2zfg9vPi6NhIzi2fjoSxEEKISuF0F7FwYzLvLd3Jih2Hju5vFx3MNd0bcW33RoT4SW+5PBLGQgghKt221Gxmr9zN7FV7yMp3AeDjZSseid2Y7k3CLK7Qs0gYCyGEqDL5Tje/bE5l1vJdLElKO7q/Y0wI/VpF0KdZBL2bhdX5qTcljIUQQlSL3em5zF61mw+W7SKrwHV0f0SgD4M7NqBnXBgXt44ioA6OxpYwFkIIUa0y852s3H6IFTvSWbgxhe1pOcc83jIqkM6xoXRoGEyHmBBaNQgiuJaPzJYwFkIIYRmtNX/ty+SHjcksTUrj992HKS9+YsP8GNwxmrjwALo1qUfLqMBatdSjhLEQQgiPkVfoZsOBDNbvz2TNniNsSc5ia3I2Ba6iY9oF+njRrmEw8U3qEd+0Ht0bhxHiX3N7zxLGQgghPJrLXcSiLan8sfsIO9NzWJqUdswazABKQauoIKJDfWkY6kfzyECahPnTISaE+sE+Ht+LPlkY172z50IIITySl93GJW3rc0nb0rWV07ILWLP7CKt2HWL1zsOs3XuEzclZbE7OOuH5gT5eNI8KpEVkIC2iAmnTIIgWUYE0DPXDbvPwkJaesRBCiJoir9DN1pQskjML2Jaazb7DeWxOzmJrctYJvegSdpsiKsiHqGBfGgT70CDYl/ohvjQINreW9YOIDPKplvqlZyyEEKLG8/O206lRKACXUf+Yx9KzC0hKyWZrSjZJKdlsOpjJ9tQcUrIKOJCRz4GMfNae5HWbhvvTrUk9mkcG0jEmhDbRQUQGVt9hbwljIYQQtUJ4oA/hgT70ahZ+zP4Cl5uUzAKSM/M5mJlPcsl2Rj77juSx+WAWO9Nzj863XSLEz0GDYF8CfOwE+jqo52/u1w/2JTrE9K6ji3vY5xraEsZCCCFqNR8vO7Fh/sSG+Zf7uMtdxLp9GWw6kMWf+zLYkpzFluQsMvKcZOSVf+i7rGBfL6JD/Aj1dxAW4E14oDcRgT4Uuopo3SAIX4cdP4cdP2/7SV+jQmGslBoIvArYgbe11i8c97gqfnwwkAvcqrX+vSKvLYQQQljJy26jW+N6dGtc7+g+rTWpWQWkZReSU+giO99Fek7h0R71wTI960M5hWTmnzig7IxqOF0DpZQdeAO4DNgLrFJKzdNabyjTbBDQsvjWC3iz+KcQQghR4yiliAr2JSrY95TttNakZReSll3A4ZxC0nMKSc8uYNXOwwT42Ml3FpHndJPvdJNX6GbXSV6nIj3jnkCS1np7cYGzgauAsKq1HAAACe5JREFUsmF8FTBTm6HZy5VSoUqpaK31gQq8vhBCCFEjKaWIDPI5YTT2refFld9+bPmvU5EwjgH2lLm/lxN7veW1iQGOCWOl1BhgTPHdbKXU5gq8f1WJANJO26r2ks9fdz9/Xf7sIJ9fPr+1n79JeTsrEsblDRE7/uLkirRBa50AJFTgPaucUiqxvGu96gr5/HX389flzw7y+eXze+bnr8jCknuB2DL3GwH7z6KNEEIIIcpRkTBeBbRUSsUppbyBYcC849rMA25RRm8gQ84XCyGEEBVz2sPUWmuXUmocsABzadO7Wuv1Sqm7ih+fBszHXNaUhLm06baqK7nSeMThcgvJ56+76vJnB/n88vk9kGVzUwshhBDCqMhhaiGEEEJUIQljIYQQwmI1PoyVUvcqpTYrpdYrpf5bZv9jSqmk4scGlNnfXSn1Z/FjU4qn8kQp5aOU+l/x/hVKqaZlnjNSKbW1+DayzP644rZbi5/rXT2f+lhKqX8qpbRSKqLMvlr9+ZVSE5VSm5RS65RSXyilQss8Vqs/+7lQSg0s/r0kKaX+ZXU9Z0IpFauU+lkptbH43/v9xfvD1P+3d/4xclVVHP9807VtBEq3xdIVUNg/aACNbQPqSosrEIKb2sSIcUlIlMYoP0KiJhaw/qggJG0jKcbE1pC04i6EsoANTbWlhPJDsFBrqyZ0oQuLFCgIpSo0VKDHP+6ZzNvpzG7HZeftzJxP8vLuO+/eN/fc92bPvHPvniM94PfiAUmtmTZj/izUEkkTJP1F0gY/bibdp0rq8+/905I6Gkp/M6vbDfgCsAWY5MczfH8msAuYBJwGDAAT/NyTQAfpf6N/D3zR5VcBq7zcDdzl5WnAc75v9XKrn1sHdHt5FXBlDmNwCmlx3QvACc2iP3AR0OLlZcCyZtF9FGM2wcejHZjo43Rm3v2qov9twFwvHwc84/d7OXCdy6+r9bNQ4zH4HnAHsMGPm0n33wDf9PJEYGoj6Z/7F2yUN2cdcGEZ+fXA9ZnjTT74bcDujPxSYHW2jpdbSBFalK3j51a7TF6nYBA6gE05jEEf8ClgkKIxbhr9/bO/DPQ2o+5VjtOQfpaOVb1twHpSzPx+oM1lbUB/rZ6FGut7MvAgcD5FY9wsuk8BnscXHWfkDaN/vbupTwfmu0vhYUnnuLxSeM6TvFwqH9LGzN4D/gVMH+Za04EDXrf0WjVB0kLgJTMrzZfdFPpnWET6hQvNp3s1VNKn7nAX4hxgG3CieVwD38/warV4FmrJSmAxcDgjaxbd24F/AmvcTX+bpGNoIP3HfT5jSVuAmWVOLSH1vxX4LHAOsE5SO5XDcw4XtrPaNkcVAnS0jKD/D0ju2iOalZHVnf7D6W5m673OEuA9oLfQrEK/6kr3MaJe+z0ESccC9wDfMbN/q3JS91o8CzVB0gLgNTP7s6TOo2lSRlaXujstwFzgGjPbJulWklu6EnWn/7g3xmZ2YaVzkq4E7rXkO3hS0mFSEPBK4Tn3erlUTqbNXkktwPHAfpd3lrTZSnJhTJXU4r+ixiQEaCX9JX2SNBeyy/8YnQzskPRpGkT/4e49pEUVwALgAn8GoEF0HyPqPmytpA+RDHGvmd3r4lflWeIktQGvubwWz0KtOBdYKKkLmAxMkdRDc+he6NteM9vmx30kY9w4+tfS7z8G8whXADd4+XSSK0HAWQydvH+O4uT9U6Q36cLkfZfLr2bo5P06L08jzVW0+vY8MM3P3c3QRTxX5TgWgxTnjBtef+BiUhrPj5TIG173UYxZi4/HaRQXcJ2Vd7+q6L+A24GVJfIVDF3Es7yWz0IO49BJcc64aXQHHgVmeXmp694w+uf+BRvlzZkI9AB/B3YA52fOLSGtoOvHV8u5/GyvPwD8kmIUssmkP7B7SKvt2jNtFrl8D3B5Rt7udfd420k5jsUgboybQX//zBeBnb6tahbdRzluXaRVyAMkd3/ufaqi7/NI7sG/Zu57F2le70HgWd9Py7QZ82chh3HopGiMm0Z3YDaw3e//70iGsWH0j3CYQRAEQZAz9b6aOgiCIAjqnjDGQRAEQZAzYYyDIAiCIGfCGAdBEARBzoQxDoIgCIKcCWMcBGOAUhatkbZBr7tW0t4RLlkTJA16MIkP8nprj6Le2sJ4BEEzMu4jcAVBndJRcnwfKQjB0ozsUM16EwTBuCaMcRCMAWb2p+yxpEPA66Xy0SJpkpmFUQ+COifc1EEwTpA0R9Kjkg56EvMrSs5/w93b50m6W9IBUtYiJLV4MvXdkg5JelnSzyVNzrRvkXSjpAFJ70h6XdJjkuaV6Uu3J3B/W9L2CnUuk7Qrc63fenzgkfS8QNIObzcg6dv/14AFQQMRb8ZBMD6YQkoavxK4Abgc+JWkfjN7qKRuL3AncAnF73AP8CVgGfA4cAZwI3Aq8BWvcy3wXVKYwJ3+mWeTYu9mmQ/MAn4EvOPX2SDpVDM7ACDpW6S8rneRcsd+FLgZ+IykuWb2VjklJZ0BbCSFNewmxQ5eChwLvD/iKAVBgxLGOAjGB8eRkk08BCDpEVJ6zEuBUmPcZ2aLCweS5gNfA75uZre7eIuk/UCPpNlmtpM0j73ZzG7NXOv+Mn2ZAsw2szf9+vtIwfW7gDskTSAZ6K1m1p3px25SMP9FwC8q6PlD4D/ARWb2trd7nBQnuK4ySAXBB0m4qYNgfHAw+wbs88DPAh8rU/e+kuOLgf8C97grusVTwG328+f5/imgS9JNkuZJmlihL08UDLHzN98X+jKLlMS9N9vIzB4DXgA+X0lJ0g+CjQVD7O1eBP44TJsgaHjCGAfB+ODNMrJDpEwypbxScjyDlMHsLeDdzFbI7Trd9zcDPwEWkt5g35C0RtIJJdfbnz3ILBAr9KXg1i7tB8A+jnR7Z2kDXi0jLycLgqYh3NRBUH+Uplp7gzS3O79C/ZcBzOxd0pzyMkkzgQXALcCHSW7uo6VgrGeWOTeTNB9ciVeAE8vIy8mCoGmIN+MgqH/+QHprPd7MtpfZjpiLNbN9ZnYbsAX4RJWf1096k+3OCiV9Dvg48PAwbZ8gucqPybQ7BTi3yj4EQUMRb8ZBUOeY2VZJdwJ9km4hJUY/TFpJ3QVca2bPSFpPCjyyg+QWn0Oab15d5ee9L+nHwGqP1tUDnATcRJrnXjNM858BXwU2S1pBcq//lHBTB01OGOMgaAwuA64hrWReQppvHgQ2UTR0j5AM4dUk1/Q/gOUkI1oVZvZrSQeB7wPrSfPVG4HFlf6tyds9LakLWEH6t6iXSK7zDqCz2n4EQaMgs9LppyAIgiAIaknMGQdBEARBzoQxDoIgCIKcCWMcBEEQBDkTxjgIgiAIciaMcRAEQRDkTBjjIAiCIMiZMMZBEARBkDNhjIMgCIIgZ/4HlVReWimvOaUAAAAASUVORK5CYII=\n",
      "text/plain": [
       "<Figure size 576x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# 使用matplotlib绘制精度和召回率相对于阈值的函数图\n",
    "def plot_precision_recall_vs_threshold(precisions,recalls,thresholds):\n",
    "    plt.plot(thresholds,precisions[:-1],'b--',label='Precision', linewidth=2)\n",
    "    plt.plot(thresholds,recalls[:-1],label='Recall', linewidth=2)\n",
    "    plt.xlabel('Threshold', fontsize=16)\n",
    "    plt.legend(loc='upper left', fontsize=16)\n",
    "    plt.ylim([0,1])\n",
    "    \n",
    "plt.figure(figsize=(8,4))\n",
    "plot_precision_recall_vs_threshold(precisions,recalls,thresholds)\n",
    "plt.xlim(-700000,700000)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAf0AAAF5CAYAAACV7fNGAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjAsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy8GearUAAAgAElEQVR4nO3deZgU1b3/8c93ZhiEAXRYBBdQMa4QgUi4wSCMCzHE7adXcQsuMcE9uRhN9Lqh8epzjduNSxRFoqIo3sQtaiQxIsRgdOBKFI0GEFEQAdkcdpjz++Pbk54ZZ+mZ6a7q5f16nn7qdHV19ZcW+XSdOnXKQggCAAD5ryjuAgAAQDQIfQAACgShDwBAgSD0AQAoEIQ+AAAFgtAHAKBAEPoAABSIyEPfzHqa2cxmtploZrPM7Oqo6gIAIN9FGvpmVi7pYUllTWxzoqTiEMJQSX3NbJ+o6gMAIJ9FfaS/XdIpktY1sU2FpKmJ9jRJwzJcEwAABaEkyg8LIayTJDNrarMySUsS7VWSvlF/AzMbK2msJJWVlR28//77a+1aadWqxJsSy759pfLy9NQOAEC2mD179soQQo+Wvi/S0E9RlaQOiXYnNdAbEUKYIGmCJA0ePDhUVlbWeX30aOmpp6Sbb/Y2AAD5xMw+bs37snH0/mwlu/QHSFoUXykAAOSPWEPfzA40sxvrrX5G0hgzu13SaEkvtHS/110nvfqqVFHhz0OQ/vY36dNP21gwAAA5zLLx1rqJUf4jJc0IISxratuGuvdrmzdP+vGPpQ0bpEMOkW67Lc3FStq4Udq8WdppJ3++bZs0f75UWurjCiTpr3+VzjrL1+++u3T88dLpp/v4g2OO8W0++0yqrJQ++cQf5eXSN78pLV0q7buvtyX/QXPMMdK4cdIll0g9e6b/z9SQ7dulNWu8rqJs7CMCgAJhZrNDCINb/L5sDP2WaCj0ly+XZs6UXnhBmjJF2rRJ+vrXpddflzp3bvlnLFsmrVjh+6iu9h6DPn38tQ0bfJ/V1dLAgb7uvfekLVuk886T7rvP173zjnTQQV/dd2mp/2goKpIeecR/GDTk0kuTP1jGjZPuvDP5Wp8+0hNPSN/6lmTm+5szx+tetkz6/PO6y4kTpf79pY8/liZP9j/bp59K7dtLBxwgffGF1KWLdP31vv/qamnnnX19fUOGSOeeK40dK737ru+nQwf/gdWuXcu/awBA81ob+tk4kK/N5s2TTjop+fycc6Rbb2048P/wB+nuu6Wf/UwaPrzua6++Kl15pZ8akDxcN26USkr86FuSOnb0UJSkt99OvnfPPeteObDffr6fp5+WHn1UWrlSOvBAaY89pPXrvbb995dGjfKegAce8F6C3XaTdt01+YNCkr7zHenFF6UPP/Tnixd7yK5e7b0Nn34qDWviQsdPPvHQ/+wz6epGpj/aa69k6BcVJf+M9Z14oge/JF18sfTaa3Vf32kn39frr/uPAQBAfPIy9Gt3Pd91l4fRuedKDz3k66ZMkU491dvPPec9Ah99JM2e7UG4117+Wvv2ycCXPFwlD+W1a6Udd/Tn77wjPfaYB/1BB3mg1v+BUVrq4ThkiF9V0JAhQzzMJWnChMb/fKNG+WPhQunb3/YfDfvtJ335pYdsr15+1N+rl3f911/26+f72Wsv6ec/l7p2lZ55xuvu1s0fu+5a9zPnz/ej/y1b/EfFBx/4n2nXXb0HpKb++qG/Zo1/X5s3+/f5n/8pvfWW/+j57DPvZfj2t6UzzpAuuMDfU1npP6qWLvX977mn17xlS/KHw/bt/t+jSxfv3Wjf3n+ANX01KAAUtrzs3t+40bvJR43yo3zJA+mtt5Lb1Pyx779fOv98b++yix99/+lP/nz7dv9B0LWrd70fdJA0cqSfXydcGrd9u7RkibRggZ/+kLx34sAD/cdDQ664IvljqH9/762pr3t3/5Eg+WmKXXZpeF/nny/de6+3q6q8Z4ZeBgD5hO79Wjp0kKZOrbtu6NC6of+Pf3h3+pFHJtd99pkfDdcclRYXS8cd56811V2OuoqL/VRIzbiHGr/9rY936N7dHx9/LM2YIb3/vvTd7ya3GzHC/xvOmVP3tMLGjf5jzazxSZc6dvRehOXLfdm/f93Xx4yRXnnFe1QGDPB199zjtYwc6T9SunXz93ftmrwCZMMG3195eevGhQBANsjLI/2GVFd7wBx5pJ8ff/ppqXdvD5HDD/egv/JKHxXPUXx2qa72wZgdO371tZofARs2eJi/+qp0ww1Sp05N9wbceaf0k5/4KZE+ffw0RENq/vd44YXkVRaSnzbafXdfV5KXP50BZDOO9JtRVORHbStW+HnvmmA386BA9ioqajjwpeR/x44dpWOP9UeNXr08tCsrpd/9zntvvvhC+uMfpaOP9m06dfIffLvt5qck9tzT3/fGG9JhhyX3Vf/KhUsuSbY/+cR/AFxzjV8hMW6cXwUBANmmYI70gXQYPdp/QGzf7s/vv1864QQfTPm97/mpivruu88v39y0yX8U9OlDbxKAtmntkT5TrAAtMHWqT74Ugh/9V1RIPXp4j0Fj4z5qxiV8+KH3JBQVeegfeaRfCbF1a1TVAyh0hD7QSl27+pUckg9MnDDBA37hQn88+qi/dvrpvqx/RcIrr/i4klNPlWbN8nX/9V/SPvtIp53mPyQGDfKJj958M5o/E4D8Rvc+EKHNm6Uf/EB6+eXkOIFDDvEZJIuKfLKmmvkg6nvnHWnvvaVf/1pat85/TOyxh49VAFBYmIYXyDHbtiUvD625AuDuu/3c/6ZN0i23+NUFko8XeOEFH2y4++4N7+/RR6Xvfz+a2gHEi3P6QI4pKZHKyupe8nfxxdJll/n0yOvW+diBEDzwJT+N0JiaiYsmTfIxA7/4ReZqB5CbCH0gh7Rvn/whEIJPMvXqq9KTTybvN3HttcmlmU9QNHly4/dPAFA4CH0gh+23n19BMHq0DwqUpAcfrLvNvHk+E+HQof78qaf8x0DNfBUnnyyNH++XEwLIb5zTB/LQmjUe5M8/71cSSH5p4LZt0nXX+XiB+tq396mSjz5amjtXevZZH3NQXu6TF/Xu7Zcn7r67n5YAEB8G8gFo1Pr1yaB++22fH+Cuu/zOkjVXEQwf7kG/007Sbbf52IKGnHGGny7Yts1nLhw0iB8BQNQYyAegUbVDeeBAv2fAyy/7TYRC8BkG77rLA1/ymx4NGuRH9UccUXdfgwb5cuVK6dBDfT4BM59pcORIprUGshlH+gBa5bPPpF13bfi1117znoOaf16YdhhIL470AURql138ioB33/X5BU45JfnasGH+2pw5PunQfvtJ//M/0m9+4zco2rw5trKBgsaRPoC02b7dZxesqJCqqqSdd5Y2bmx425/+VLr11kjLA/IGR/oAYldc7IEv+bn+xYt9QODXvy59+9vJ7X70I787oSQ9/rjfhbChOxQCSC+O9AFEats2nzvgoIOk//5v6aWXpBkzkq+PH+/3GDjpJGmHHWIrE8hqHOkDyAklJdKAAT6476STpM6d674+frxPJjR3rj//4gvfdtAgv8nQ0qV+GgFAyxH6AGLzta9Jv/+9j/K//fbkbYj32st7BKRkt//bb0tTpvhEQSUlPkBwyZJ46gZyFaEPICuMGyc99pj/AFi4MDkGYJ99/Jx/zRwCNUKQVq3y9pw50vHHJycaAtAwQh9AVuvZU7rvPmn16uSNhn73O+mqq/yugytX+sRCzz3nz3fbTXr6ab96IMeHLAFpx0A+ADlt+3apXz/pgw+++tree/v6EHx+gD33ZKIg5AcG8gEoSMXFfovh6mrp2GPrvjZ1qp/7X71a6tvX22PGSG+9FU+tQNwIfQB5wcy7+GtOAbz7rrTHHr7+00+T202eLA0Z4ut32UV64AFfv20bpwOQ/wh9AHmpXz+pWzdvDxrkg/yGDKm7TZ8+Upcu3p4923sCxo2Ltk4gSpzTB1BwFi70uwz27u13HJSk/ff/6riA8eOlSy/96lwCQNxae06/JBPFAEA269tXuuCCuutmzvR7BdQ2frwvr7sukrKAjKN7HwAk9ejh5/SXLJFGjfKufkk6+WRf3nST3y3w7bfjqxFoK470AaCWXXeVXnyx7rrt230A4Icf+vgASVq0yAcKArmEI30ASME++9R9XnPN/+zZsZQDtAqhDwDNKC6Wnn3Wu/9HjUqu79DBrwCQpEsu8R8CK1fGUiKQErr3AaAFarr+Fy/26X579PCgv/tuX9+jhy/ffFP65jfjqRFoDEf6ANAKffpIP/mJt7t3/+ocAEOG+J0DgWxC6ANAGvztb8mbAdW444746gEaQugDQBqdcILP9S/5OICtW/2eADXrgDgR+gCQZjvt5Ef93/iGNH269PvfS127+mj/ceOY4x/xIfQBIIP+/Oe6z++80yf+mTw5nnpQ2Ah9AMigm2/2Lv5bb627/sknpY0b46kJhYvQB4AMKymRfvpT79afP9/XXXmlVFoqvfWWtHlzvPWhcHCdPgBEaO+9PfxDkKZMkX7wg2Tob9+enPMfyAT+egFADMw89Gsf5RcX+/pVq+KrC/mN0AeAmDz/vLRhg3TwwXXXH320H/UD6UboA0CMOnSQKiulzz/358ceK82c6Uf9l18uXXppvPUhv3BOHwCywM47171+f+5c6fHHpaVLpalTfa5/zvejrfgrBABZaN99PfAlackSP/Knyx9tRegDQBbq0EHatKnuupISHwMAtBahDwBZqn177/KvuV1vv37J0f5/+EN8dSF3EfoAkOWWL5cmTZLOO08qL/eb94waJf3yl3FXhlxD6ANADjj7bOmSS7w9cqQvf/YzP/p//XVu4oPUEPoAkGMefjjZfu89adgwH9n/0EPx1YTcQOgDQI7p109auVI67LC66089NZ56kDsiD30zm2hms8zs6kZeLzezF82s0szuj7o+AMgF3br5bXtDkKqrfYKfjh2lqiqfyvdHP/K7+wG1RRr6ZnaipOIQwlBJfc1snwY2GyPpsRDCYEmdzWxwlDUCQK4x86l8q6ulPfbwdQ8+6Hfx+9//jbc2ZJeoj/QrJE1NtKdJGtbANl9I6m9mO0nqLemTaEoDgNxWVORH/LWdfLL/KFi+PJ6akF2iDv0ySUsS7VWSejawzV8k7SHpx5LeT2xXh5mNTXT/V65YsSJTtQJAztlrL+/ynzat7vqpUxveHoUl6tCvktQh0e7UyOdfJ+n8EMINkv4h6Zz6G4QQJoQQBocQBveombUCAPAvI0d6+N9yi/S1r0kXX+zrjztOateOS/wKVdShP1vJLv0BkhY1sE25pK+bWbGkf5PEX00AaKXLL5f++U9v33uv38532zY/FcBAv8ITdeg/I2mMmd0uabSkeWZ2Y71tbpY0QdJaSV0lTYm2RADITxdcUPd5aSk38Sk0kYZ+CGGdfDDfG5IOCyHMDSFcXW+bN0MI/UIInUIII0MIVVHWCAD5ysy79S+7LLluxx3jqwfRi/w6/RDC6hDC1BDCsqg/GwDgc/Zfe62316/3iX5QGJiRDwAK0PXX+/S9kydLXbtK06cT/oWgJO4CAADxmDlT2rJFuuEG6aabfGAfo/rzG0f6AFDASkulAw9MjuS/5pp460FmEfoAUOBGj062b7zRB/zNmxdfPcgcQh8AoA0b6j7v3196++14akHmEPoAAHXo4Ofz777bnx91lHf7I78Q+gCAf7noIr9b3+TJfr5/wQJpxAgG+OULQh8AUIeZ1L279NprPm//jBl+rh+5j9AHADRoxIhk+9prpU+40XnOI/QBAI2qrEy2+/Txo3/kLkIfANCogw+Wrq51h5SKithKQRoQ+gCAJv3iF9KcOd5+4w1ffvSRD/hDbiH0AQDNGjRIWrpUGjhQ+vJL6eijpeJin8IXuYPQBwCkZJddpPbtpb/+VXr/fV933XXx1oSWIfQBAC1y1FHS4sXJ57fcEl8taBlCHwDQYr17S926efvnP5fWrIm3HqSG0AcAtMo//pFsn39+fHUgdSVxFwAAyE3du0tXXSUtWSKNGxd3NUgFoQ8AaLWa6Xmrqvxc/0svSUX0IWct/tMAANrMTJo2Tdp777grQVMIfQBAmz31lC8XLZL694+1FDSB0AcAtNnZZyfb8+ZJs2fHVgqaQOgDANJi69Zke/BgadKk+GpBwwh9AEBalJRIv/udt8vLpbKyeOvBVxH6AIC0OeEEacUK6fTTpZNPlrZvj7si1EboAwDSqnt36e67/S58JSXSD38Yd0WoQegDADKiXz9fTpzol/SFEG89IPQBABny97/Xfb7nnrGUgVoIfQBARpSW+tH94Yf788WLpcsvj7emQkfoAwAy6k9/Sraffjq+OkDoAwAyzEzavNnb9bv8ES1CHwCQcTVd/R07So88Iq1aFXdFhYnQBwBE5te/lsaPl7p1i7uSwkToAwAi88EH0kcfeXvMmHhrKUSEPgAgMnfckWxPnuzd/dXV8dVTaAh9AEBkzKRt25LPN25kxr4oEfoAgEgVF/ugvnbt/DmD+qJTEncBAIDCtHKltGCBNGhQ3JUUDo70AQCx6NIlGfhz5kjDh3NXvkzjSB8AEKtLLvG78kl+Vz5uzJM5HOkDAGL1y1/Wfd63bzx1FAJCHwAQqx12qHt0/9FHPsr/yy/jqylfEfoAgKwQglRR4e3TTpPefz/WcvISoQ8AyBqvvir95jdS165Snz5czpduhD4AIKucdZZ0113Su+/6HP3r18ddUf4g9AEAWenmm305aVK8deQTQh8AkHXMpKoqb19ySby15BNCHwCQlS64INnmpjzpQegDALLSmWcm28XF8dWRTwh9AEBWKiqSevdOPt+6Nb5a8gXT8AIAstbixdIBB0gnniht2pS8Mx9ah9AHAGS1mkl6OK/fdnTvAwCyXgjSZZf5qH60HqEPAMh6L74o3XGHt5msp/UIfQBA1vve95LtXr3iqyPXEfoAgKxnJg0a5O2qKp+fHy0Xeeib2UQzm2VmVzez3b1mdmxUdQEAsttbbyXb55xT93a8SE2koW9mJ0oqDiEMldTXzPZpZLtDJfUKITwfZX0AgOxVXCy9/nry+UcfxVdLror6SL9C0tREe5qkYfU3MLN2kh6QtMjMjo+uNABAtjvkEGnqVO/i79s37mpyT9ShXyZpSaK9SlLPBrY5U9J7km6RNMTMvnKrBTMba2aVZla5YsWKjBULAMg+J58slZVJF14oTZwYdzW5JerQr5LUIdHu1MjnD5I0IYSwTNJkSYfV3yCEMCGEMDiEMLhHjx4ZKxYAkJ3+8hdp4ULphz/k3H5LRB36s5Xs0h8gaVED28yXVNNpM1jSx5kvCwCQSw44QHr5ZW+/9FK8teSSqEP/GUljzOx2SaMlzTOzG+ttM1HSYWY2Q9KFkm6NuEYAQJbr1k0aONDbRx/NhD2pinTu/RDCOjOrkDRS0i2JLvy59bb5UtLJUdYFAMg9t90mHXGEtzt1ops/FZFfpx9CWB1CmJoIfAAAWuXww6VTTkk+/9Wv4qslV3CXPQBAznriCWnVKumii6Tjjou7muxH6AMActq0ad61byZdd530ySfSQw/FXVV2Yu59AEDOM5Nuvlm64QZp0iSpujruirIToQ8AyAsXXphsFxfHV0c2I/QBAHlhxx2lQw9NPl+4ML5ashWhDwDIG9OnJ9s33BBbGVmL0AcA5I2iImn//b39z3/GW0s2IvQBAHnl2Wd9OXNmvHVkI0IfAJBX9t1X2rzZj/rvuEP629/irih7EPoAgLxTWiqtXes34/nWt+KuJnsQ+gCAvLRmjfTHP3r7+uvjrSVbEPoAgLy0xx7J9vjxsZWRVQh9AEDemjEj2V63Lr46skXaQ9/MOqR7nwAAtMawYcn2j38cXx3ZotnQN7NSMzs00S42s2ObecsvzIwpEQAAsTOTRo3y9vvvx1tLNkjlLntdJf1JUvvE9k9IKmti+10kfdH20gAAaLtHHpHee08aPjzuSuKXSvf+5sRDIYTNkrbVftHMHjOzHWut2kXS39NWIQAAbdC9uwd+dbW0bVvz2+ezVEK/WtJ2M3vAzL6U1MnMVpvZl2Y2UtJpkt41s28mth8gaVaG6gUAoFWOOUZq1076/PO4K4lPSwby/Y+k4yWtl/T/JL2deP9aSddI+oOZXS5pYwhhXroLBQCgLV56yZdf+1q8dcQpldAfISmEEN4NIfxZ0rYQwmuSViZeDyGE30g6S9LNkh7PSKUAALTB6NG+rKoq3KP9JkPfzH4n6ZkU9/VviWX7NlUEAEAGPPFEst2rV3x1xKm5I/27JVVIkpkNNbNzJJWa2ZmSeie2KTGzByWdLOkISSeZmWWoXgAAWsWMa/WbDP1Ed/5cSSYP//+QH8n/VFJHSZskdUq8PiTR7b9EEhdGAACyzu23J9vLlsVXR1xSHcgXQgg3SxokaUMIYUAI4UD5KP0NIYRzQwg1ExxOlzQ0/aUCANA2xcXS3XdLixdLPXvGXU30WjoN7w6Sak+za5KerLfNu5IObktRAABkykUXSb17S089Jc2fH3c10UplRj5Jam9mFyfa/2FmP5S0QdJnkm4xs04hhKrE6wskPZXmOgEASJsPP5QmT5bGjvVb8BaKVEJ/u6R/SDpDUqj1vrLEo5ekdmb2oaRpkh4KIUzNQK0AAKTFhx9Kzz8fdxXRazb0E0fwTXbXm1kfSYdLOlXSHDMbHkJ4PT0lAgCQXkcfnWy/95504IHx1RKlFt9a18x6mFn32utCCItDCL8JIXxX0gACHwCQzWpfWL5gQXx1RC2VW+t2MLOfmttB0o8kndnY9iGEd9NZIAAAmXD88b5ctCjWMiKV6pH+OEn9Jd0rvzZ/i5nNNrNPzWxhvccHZjY+UwUDAJAOa9f68v77460jSs2Gfghho6St8rDfJL+17lZJ5fLBfR0knVNr+a6ky8ysOEM1AwDQZiNG+LK8PN46otTkQD4zGyUP+vaSBkvqKQ/9eZIUQnjNzDYmlpsSy62S7pHfkhcAgKz0859Lw4dLhx8edyXRaW70/qOSNkrqIekWSV3kR/lXNfaGEMJf01YdAAAZ0qGDB/7GjdI//yntu6+0ww5xV5VZzc293z2E0FvSp/K59x+R9IvGNk9vaQAAZN4RR0gDBkiXXRZ3JZmXyuj9YnmPQJGkUvnUu0X+kl0rqbz2suaRyaIBAEiXsjJf3nNPvHVEIZXR+zskHuslvZlol8rn3O8pPwVQLu8F6J5Y1ycTxQIAkG6/+lWy/f778dURhVRm5FtvZhdK2hJCmGhmJ0taGEKYbWbnSto7hPCfGa8UAIAMOOCAZHviROnWW+OrJdNSvU7/NEnzzexUSU9Ies/MfiPpCkmvZKg2AAAiUVHhy9tui7WMjGvukr1T5JfsPSy//r7m99BRktbIB/WVmdlxtd5WLL/E76kQwva0VwwAQJqdeaY0fbq3N23K31H8zXXvj5e0WT4yP8gH8Zmk3yZeXyCpKrGu9j7bS/p94jUAALLaWWdJK1ZIl19ed17+fNPcJXsHhBAGShouaZakn8vD/yRJL0raSdIUSYNDCIMSj6+HEPZN3J0PAICsV1Qk/exnHvhz50pPPBF3RZmR6jn9qfJR+e/Jj+pfDiEcK+l7kk6R9LpZPv82AgAUgpkzpYEDpdNOi7uSzGh29H7C2SGEzyXJzPYKIWyQpBBCpZl9S9KQEAKT8wAAclrv3sn2li1SaWl8tWRCSkf6NYGfaH9c77VtTL0LAMgHe+yRbHfoEF8dmZJq9z4AAHnPLHn5XnW1NGVKrOWkHaEPAEAtr9SafebaPJtUntAHAKCWoiLpgQe8PXRovLWkW6oD+QAAKBhnny0df7zUo0fclaQXR/oAANRTUpJ/gS8R+gAANOjvf5cuvlh6/PG4K0kfQh8AgAbMmiXdc490xhlxV5I+hD4AAA3Yf/9ke9Gi2MpIK0IfAIAGjBiRbN95Z3x1pBOhDwBAI4YN8+Ujj8RbR7oQ+gAANOLss325erW0fn2spaRF5KFvZhPNbJaZXd3Mdj3N7P+iqgsAgPrGjPHl2LHS8uXx1pIOkU7OY2YnSioOIQw1s4fMbJ8Qwj8b2fxWSXl4uwMAQK4oLZWWLZM6dpQ6d467mraL+ki/QtLURHuapGENbWRmh0taL2lZNGUBANCwnj098HfaSbrggriraZuoQ79M0pJEe5WknvU3MLNSSddIuqKxnZjZWDOrNLPKFStWZKRQAABqTJkiDRgg3XeftGVL3NW0XtShX6Vkl32nRj7/Ckn3hhDWNLaTEMKEEMLgEMLgHvk4TyIAIKucdJI0Y4a3n3su3lraIurQn61kl/4ASYsa2OZISReZ2XRJA83swWhKAwCgYe3aSXvu6e2PP461lDaJOvSfkTTGzG6XNFrSPDO7sfYGIYThIYSKEEKFpLdDCD+MuEYAAL5i3319+fLL8dbRFpGGfghhnXww3xuSDgshzA0hNHrpXiL4AQCI3YABvqysjLeOtoj8Ov0QwuoQwtQQAiPzAQA5o6LCl7k8lCzS6/QBAMhVhx4q3XZb3Rvx5BpCHwCAFHTuLF16adxVtA1z7wMA0ALz5/sjFxH6AACkaOpUaZ99/JGLCH0AAFJ0yCHJ9uzZ8dXRWoQ+AAAp2n33ZHvw4PjqaC1CHwCAFrjvvmR79er46mgNQh8AgBY477xk+7rr4qujNQh9AABaaNQoXy5eHG8dLcV1+gAAtNBTT0kLFkgHHRR3JS3DkT4AAC1UVuaBv2aNdM01cVeTOkIfAIBW2LhROuoo6cYbpYUL464mNYQ+AACt0KGD9Oab3n7mmXhrSRWhDwBAK9Vcq//kk/HWkSpCHwCAVjr0UF/OmRNvHaki9AEAaKV//3dfbtsmbd0aby2pIPQBAGiloUOT7Vmz4qsjVVynDwBAKxUVSccdJ336qdS+fdzVNI/QBwCgDZ59Nu4KUkf3PgAAbVRdLV1wgS+zGaEPAEAbPfec9PDD0p//HHclTSP0AQBoo6uv9hn6Lr447kqaRugDANBGP/iBLz/4IN46mkPoAwDQRmPHJtubN8dXR3MIfQAA2qhTp2R7ypT46mgOoQ8AQBqdc07cFTSO0AcAIA2ef4cqJLUAAAutSURBVN6XH3wghRBvLY1hch4AANLgmGOklSul0lLJLO5qGsaRPgAAadKtm9SunTRiRHZO1EPoAwCQJiFIHTpIM2ZIjz8edzVfRegDAJAmZtLuu3t7zJh4a2kIoQ8AQBrddFOyvWVLfHU0hNAHACCNvv/9ZHvu3PjqaAihDwBAGplJnTt7+5FH4q2lPkIfAIA0GznSl5MmxVtHfVynDwBAml11lTRwYPJGPNmC0AcAIM2+8Q1/ZBu69wEAyJDZs6V58+KuIonQBwAgA+66SxoyROrfP+5Kkgh9AAAy4Mgjk1PxrlwZby01CH0AADLggAOS7T33jK2MOgh9AAAy5JxzfLl+vbRmTby1SIQ+AAAZ8+CDyXZ5eXx11CD0AQDIkKIi6frrvX3++fHfbpfr9AEAyKBrr5XGjpV69vRb78aJI30AADKsVy+fk//UU6Xnn4+vDo70AQCIwIsvSs8+K730kvTll/HUwJE+AAARWLpU2rJFqqqSli+PpwZCHwCACJx1VrLds2c8NRD6AABEoF076aabks/jGMlP6AMAEJErrki2f//76D+fgXwAAETETOrSxdtxnNcn9AEAiNDSpdKGDVKPHtF/NqEPAECEysr8EYIf+UeJc/oAAERszhyfonfy5Gg/l9AHACBiBx/syzFjov1cQh8AgIjddVey/c470X1u5KFvZhPNbJaZXd3I6zua2UtmNs3Mnjaz0qhrBAAgky6+ONl+9NHoPjfS0DezEyUVhxCGSuprZvs0sNkZkm4PIXxH0jJJ342yRgAAonD66b785S+j+8yoj/QrJE1NtKdJGlZ/gxDCvSGEPyae9pAU0wzFAABkzjXXJNtr10bzmVGHfpmkJYn2KkmNzj5sZkMllYcQ3mjgtbFmVmlmlStWrMhMpQAAZND++0v9+0snnCAtXBjNZ0Z9nX6VpA6Jdic18qPDzLpKukvSvzf0eghhgqQJkjR48OCQ/jIBAMi8V16RdtxRat8+ms+L+kh/tpJd+gMkLaq/QWLg3lOSrgwhfBxdaQAARGvnnaMLfCn60H9G0hgzu13SaEnzzOzGetucK+kbkq4ys+lmdkrENQIAEIkNG6Qrr/SZ+UIE/dYWoviU2h9oVi5ppKQZIYRlbd3f4MGDQ2VlZdsLAwAgYtu3SyWJE+2vvSYNH57a+8xsdghhcEs/L/K590MIq5UcwQ8AQMEqLpY6d5a+/FIaMSLzR/vMyAcAQIzGjUu2338/s59F6AMAEKPrr/eb70jSZZdl9rMIfQAAYjZ2rC9ffDGzn0PoAwAQs8sv98v3brops58T+UA+AABQV9++0uefZ/5zONIHAKBAEPoAAGSBpUulfv18op5MIfQBAMgCZWXSe+95+9VXM/MZhD4AAFlgxx2T7aOOysxnEPoAAGSJe+/15datmdk/oQ8AQJYYMybZfuGF9O+f0AcAIEt06pRsv/RS+vfPdfoAAGSRe+6R/vKXzJzXJ/QBAMgiF17oj0ygex8AgCxUVSWde256b7fLkT4AAFlm1SqpWzdvL1ggTZ+env1ypA8AQJbp2lUaNMjbr70mffppevZL6AMAkIVmzky203X5HqEPAEAWKiuTvvc9b996a3r2SegDAJClTjjBl/Pnp2d/hD4AAFlq1Chfdu0qbdnS9v0R+gAAZKnddpPefltasUIqLW37/gh9AACy2IABUlGRtHx52/dF6AMAkOUeekjq2VOaNKlt+yH0AQDIcuee68s77mjbfgh9AACy3C23+PKdd6SNG1u/H0IfAIAsd955yXbHjq3fD6EPAECW69JFOuaYtu+H0AcAIAc895zfhKdPn9bvg9AHACAHmElTp9K9DwBAQTj8cGn27Na/n9AHACCHcKQPAACaRegDAFAgCH0AAAoEoQ8AQIEg9AEAKBCEPgAABYLQBwCgQBD6AAAUCEIfAIACQegDAFAgCH0AAAoEoQ8AQIEg9AEAKBCEPgAABYLQBwCgQBD6AAAUCEIfAIACQegDAFAgCH0AAAoEoQ8AQIEg9AEAKBCEPgAABYLQBwCgQBD6AAAUiMhD38wmmtksM7u6LdsAAICWiTT0zexEScUhhKGS+prZPq3ZBgAAtFzUR/oVkqYm2tMkDWvlNgAAoIVKIv68MklLEu1Vkr7Rmm3MbKyksYmnm83s3TTXia/qLmll3EXkOb7jzOM7zjy+42js15o3RR36VZI6JNqd1HBPQ7PbhBAmSJogSWZWGUIYnP5SURvfc+bxHWce33Hm8R1Hw8wqW/O+qLv3ZyvZXT9A0qJWbgMAAFoo6iP9ZyTNNLNdJY2SdKqZ3RhCuLqJbb4VcY0AAOSlSI/0Qwjr5AP13pB0WAhhbr3Ab2ibtc3sdkIGSsVX8T1nHt9x5vEdZx7fcTRa9T1bCCHdhQAAgCzEjHwAABSInAl9ZvLLvOa+PzPb0cxeMrNpZva0mZVGXWM+SPXvqZn1NLP/i6qufNKC7/heMzs2qrrySQr/XpSb2YtmVmlm90ddX75I/Dsws5ltUs6+nAh9ZvLLvBS/vzMk3R5C+I6kZZK+G2WN+aCFf09vVfLyVaQo1e/YzA6V1CuE8HykBeaBFL/jMZIeS1y+19nMuIyvhcysXNLD8vlrGtumRdmXE6EvZvKLQoWa+f5CCPeGEP6YeNpD0vJoSssrFUrh76mZHS5pvfzHFVqmQs18x2bWTtIDkhaZ2fHRlZY3KtT83+MvJPU3s50k9Zb0STSl5ZXtkk6RtK6JbSrUguzLldCvP0tfz1Zug8al/P2Z2VBJ5SGEN6IoLM80+z0nTptcI+mKCOvKJ6n8XT5T0nuSbpE0xMwuiai2fJHKd/wXSXtI+rGk9xPboQVCCOtSuIKtRdmXK6Gflpn80KSUvj8z6yrpLkk/iKiufJPK93yFpHtDCGsiqyq/pPIdD5I0IYSwTNJkSYdFVFu+SOU7vk7S+SGEGyT9Q9I5EdVWaFqUfbkSjMzkl3nNfn+JI9CnJF0ZQvg4utLySip/T4+UdJGZTZc00MwejKa0vJHKdzxfUt9Ee7Ak/j63TCrfcbmkr5tZsaR/k8T14ZnRouzLiev0zayLpJmSXlFiJj9JJ9ee2KeBbb6VQrcIElL8ji+QdJOkuYlVvw4hPBl1rbksle+53vbTQwgV0VWY+1L8u9xZ0kPyrtB2kk4KISxpYHdoQIrf8RBJk+Rd/LMknRBCqIqh3JxX8++AmR0o6fS2ZF9OhL70r1GMIyXNSHTJtWobNI7vLxp8z5nHd5x5fMfZoyX/LXIm9AEAQNvkyjl9AADQRoQ+AAAFgtAHIDMrS4yyBpDHCH0Akl/ru83MQgqPh2reZGbDU3xP7UfvGP+cQEEribsAAFmhj6TNkrYkns+XdLuke+ttN13SZ7Web00sy1P8jLm13gMgYoQ+AIUQ/jUvupl9U1I3Sc/XnxXQzHaRtLjWqm2J9zc7e2BiDvZ/vQdA9OjeB1DftZL+EkJ4p/ZKM9tBfqOlBbVWb623zcoGuvPfqrd/Qh+ICaEPQNK/BvM9IulwSRfWWt81cde/6+VTqf69id1skHRYCMFCCCZpnKSNGSwbQAvQvQ8UODPbXdJoeUBXSzqq3lH+dkkvywf7/VcIoalbKlenuA5ADAh9oICZWXv5PbiL5LeZfTCEUOfIPISw1sx6hRC+SGWXKa4DEAO694ECFkLYLL9Bx/6Sjpe0oaHL7CTVPld/ehO73EHSq7Xed0diHYAswJE+UOBCCOsSzQ2SfivpsiY2/7ukTU28vq++emTPwD0gSxD6AGpUS6oKISxqbAMzq1YT5+i5nTWQ3ejeB9AWrTlwYLpfICYc6QOo7SwzO6uZbWr/u9FOkhLn71PVrsVVAUgLjvQB1AiSJsun1G3ssU51B+aVSFpbc11+Uw9Je9V6D4AYWAgt+YEOAElmViKpLJVz+WZWJKmL/EcC//AAMSD0AQAoEHTvAwBQIAh9AAAKBKEPAECBIPQBACgQhD4AAAWC0AcAoED8f3b9JNngAukBAAAAAElFTkSuQmCC\n",
      "text/plain": [
       "<Figure size 576x432 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.rcParams['font.sans-serif'] = ['SimHei']\n",
    "def plot_precision_vs_recall(precisions,recalls):\n",
    "    plt.plot(recalls,precisions,'b--', linewidth=2)\n",
    "    plt.xlabel('召回', fontsize=16)\n",
    "    plt.ylabel('精度', fontsize=16)\n",
    "    plt.axis([0,1,0,1])\n",
    "    \n",
    "plt.figure(figsize=(8,6))\n",
    "plot_precision_vs_recall(precisions,recalls)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 通过选择阈值来实现最佳的精度/召回率权衡"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 目标设定为90%的精度，阈值大概在300000左右\n",
    "y_train_pred_90 = (y_scores > 300000)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.9801894918173988"
      ]
     },
     "execution_count": 48,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "precision_score(y_train_5,y_train_pred_90)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.20992436819774948"
      ]
     },
     "execution_count": 49,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "recall_score(y_train_5,y_train_pred_90)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 总结\n",
    "* 获得了一个90%精度的分类器，但如果召回太低，精度再高，也不怎么有用\n",
    "* 如果工作中，需要99%的精度，你应该回应，召回率是多少？"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## ROS曲线"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 本质是真正类率tpr和假正类率fpr（错误地分为正类的负累实例比率）\n",
    "# 与召回/精度曲线非常相似\n",
    "from sklearn.metrics import roc_curve\n",
    "fpr,tpr,thresholds = roc_curve(y_train_5,y_scores)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 576x432 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.rcParams['font.sans-serif'] = ['SimHei']\n",
    "def plot_roc_curve(fpr,tpr,label=None):\n",
    "    plt.plot(fpr,tpr, linewidth=2,label = label)\n",
    "    plt.plot([0,1],[0,1],'k--')\n",
    "    plt.axis([0,1,0,1])\n",
    "    plt.xlabel('假正类率', fontsize=16)\n",
    "    plt.ylabel('真正类率', fontsize=16)\n",
    "    \n",
    "    \n",
    "plt.figure(figsize=(8,6))\n",
    "plot_roc_curve(fpr,tpr)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.958031999830035"
      ]
     },
     "execution_count": 52,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 计算曲线下面积AUC,虚线是随机分类0.5到1\n",
    "from sklearn.metrics import roc_auc_score\n",
    "roc_auc_score(y_train_5,y_scores)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* 召回率TPR越高，分类器的假正类FPR就越多\n",
    "* 虚线表示纯随机分类器的ROC曲线，好的分类器应该远离这条线，向左上角\n",
    "* 是使用精度/召回率 PR曲线，还是使用ROC，关键在于 正类非常少或者更关注假正类而不是假负类，选择PR，反之ROC\n",
    "* 例如：前面例子ROC曲线很不错是因为跟负类 非5 相比， 正类 数据5 数量真的很少"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 训练随机森林分类器，比较SGD分类器的ROC曲线和ROC AUC分数"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* 获取训练集中每个实例的分数\n",
    "* RandomForestClassifier 没有descision_function(),但是拥有dict_proda()方法，sklearn中分类器都有这两个中的一个\n",
    "* dict_proda返回一个矩阵，每行一个实例，每列代表一个类别的概率，比如这个图片 70%是5"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "c:\\users\\tians\\appdata\\local\\programs\\python\\python37\\lib\\site-packages\\sklearn\\ensemble\\weight_boosting.py:29: DeprecationWarning: numpy.core.umath_tests is an internal NumPy module and should not be imported. It will be removed in a future NumPy release.\n",
      "  from numpy.core.umath_tests import inner1d\n"
     ]
    }
   ],
   "source": [
    "from sklearn.ensemble import RandomForestClassifier\n",
    "forest_cif = RandomForestClassifier(n_estimators=10,random_state=42)\n",
    "y_probas_forest = cross_val_predict(forest_cif,X_train,y_train,cv=3,\n",
    "                                   method='predict_proba')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0. , 1. , 0. , ..., 0. , 0. , 0. ],\n",
       "       [0. , 0. , 0. , ..., 0. , 0. , 0.8],\n",
       "       [0.2, 0. , 0.1, ..., 0. , 0. , 0.1],\n",
       "       ...,\n",
       "       [0. , 0. , 0. , ..., 0.1, 0. , 0.9],\n",
       "       [0. , 0. , 0. , ..., 0. , 0.9, 0. ],\n",
       "       [0. , 0. , 0. , ..., 1. , 0. , 0. ]])"
      ]
     },
     "execution_count": 54,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "y_probas_forest"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1., 0., 0., ..., 0., 0., 0.])"
      ]
     },
     "execution_count": 55,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 绘制ROC曲线，需要决策值不是概率，直接使用正类的概率作为分数值\n",
    "y_scores_forest = y_probas_forest[:,1]\n",
    "fpr_forest,tpr_forest,thresholds_forest = roc_curve(y_train_5,y_scores_forest)\n",
    "y_scores_forest"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 576x432 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.figure(figsize=(8,6))\n",
    "plt.plot(fpr,tpr,'b:',linewidth=2,label='SGD')\n",
    "plot_roc_curve(fpr_forest,tpr_forest,'Random Forest')\n",
    "plt.legend(loc='lower right',fontsize=16)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.4373957573431084"
      ]
     },
     "execution_count": 57,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Rand 比SGD好很多，ROC AUC的分数也很高\n",
    "roc_auc_score(y_train_5,y_scores_forest)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.984375"
      ]
     },
     "execution_count": 58,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 再看下精度和召回率 也很高\n",
    "y_train_pred_forest = cross_val_predict(forest_cif,X_train,y_train_5,cv=3)\n",
    "precision_score(y_train_5,y_train_pred_forest)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.8251245157719977"
      ]
     },
     "execution_count": 59,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "recall_score(y_train_5,y_train_pred_forest)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 总结\n",
    "* 选择合适的指标利用交叉验证来对分类器进行评估\n",
    "* 选择满足需求的精度/召回率权衡\n",
    "* 使用ROC曲线和ROC AUC分数比较多个模型"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 多类别分类器\n",
    "* 尝试5 之外的检测\n",
    "* 多类别分类器 区分两个以上的类别\n",
    "* 随机森里和朴素贝叶斯可以直接处理多个类别\n",
    "* 支持向量机svm和线性分类器只可以处理二元分类器"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 解决方案\n",
    "1. 将数字图片分类0到9，训练10个二元分类器，每个数字一个，检测一张图片时，获取每个分类器的决策分数，哪个最高属于哪个，称为一对多OvA\n",
    "2. 为每一对数字训练一个二元分类器，区分0，1 区分0，2 区分1，2 称为一对一OvO策略，存在N个类别，需要N*（N-1）/2个分类器，最后看哪个类别获胜最多"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 优缺点\n",
    "* OvO 只需要用到部分训练集对其必须区分两个类别进行训练\n",
    "* 对于较小训练集合OvO比较有优势， 大训练集合 OvA 速度快，所以OvA更常用，比如svm 在数据规模扩大时表现糟糕\n",
    "* sklearn 检查到使用二元分类算法进行多类别分类任务，会自动运行OvA，SVM分类器除外"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "c:\\users\\tians\\appdata\\local\\programs\\python\\python37\\lib\\site-packages\\sklearn\\linear_model\\stochastic_gradient.py:128: FutureWarning: max_iter and tol parameters have been added in <class 'sklearn.linear_model.stochastic_gradient.SGDClassifier'> in 0.19. If both are left unset, they default to max_iter=5 and tol=None. If tol is not None, max_iter defaults to max_iter=1000. From 0.21, default max_iter will be 1000, and default tol will be 1e-3.\n",
      "  \"and default tol will be 1e-3.\" % type(self), FutureWarning)\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "array([5.])"
      ]
     },
     "execution_count": 60,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sgd_cif.fit(X_train,y_train)\n",
    "sgd_cif.predict([some_digit])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[-240253.03022811, -404369.88686027, -400656.6343977 ,\n",
       "        -300122.87909389, -511601.7708458 ,  222757.5043904 ,\n",
       "        -689685.34449376, -407512.98550529, -606159.03870695,\n",
       "        -741506.33050515]])"
      ]
     },
     "execution_count": 61,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 内部实际上训练了10个二元分类器，获得图片的决策分数，然后选择了分数高的类别\n",
    "# 返回10个分数，每个类别1个\n",
    "some_digit_scores = sgd_cif.decision_function([some_digit])\n",
    "some_digit_scores"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5"
      ]
     },
     "execution_count": 62,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.argmax(some_digit_scores)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0., 1., 2., 3., 4., 5., 6., 7., 8., 9.])"
      ]
     },
     "execution_count": 63,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 目标类别列表会存储在classes_这个属性中，按值大小排列\n",
    "sgd_cif.classes_"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5.0"
      ]
     },
     "execution_count": 64,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sgd_cif.classes_[np.argmax(some_digit_scores)]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([5.])"
      ]
     },
     "execution_count": 65,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 使用ovo策略，一对一或者一对多\n",
    "from sklearn.multiclass import OneVsOneClassifier\n",
    "ovo_clf = OneVsOneClassifier(SGDClassifier(max_iter=5, tol=np.infty, random_state=42))\n",
    "ovo_clf.fit(X_train,y_train)\n",
    "ovo_clf.predict([some_digit])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "45"
      ]
     },
     "execution_count": 66,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len(ovo_clf.estimators_)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([5.])"
      ]
     },
     "execution_count": 67,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 使用随机森林\n",
    "forest_cif.fit(X_train,y_train)\n",
    "forest_cif.predict([some_digit])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0.1, 0. , 0. , 0. , 0. , 0.9, 0. , 0. , 0. , 0. ]])"
      ]
     },
     "execution_count": 68,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 随机森林直接将实例分为多个类别，调用predict_proba()可以获得分类器将每个实例分类为每个类别的概率列表\n",
    "forest_cif.predict_proba([some_digit])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 评估分类器\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "c:\\users\\tians\\appdata\\local\\programs\\python\\python37\\lib\\site-packages\\sklearn\\linear_model\\stochastic_gradient.py:128: FutureWarning: max_iter and tol parameters have been added in <class 'sklearn.linear_model.stochastic_gradient.SGDClassifier'> in 0.19. If both are left unset, they default to max_iter=5 and tol=None. If tol is not None, max_iter defaults to max_iter=1000. From 0.21, default max_iter will be 1000, and default tol will be 1e-3.\n",
      "  \"and default tol will be 1e-3.\" % type(self), FutureWarning)\n",
      "c:\\users\\tians\\appdata\\local\\programs\\python\\python37\\lib\\site-packages\\sklearn\\linear_model\\stochastic_gradient.py:128: FutureWarning: max_iter and tol parameters have been added in <class 'sklearn.linear_model.stochastic_gradient.SGDClassifier'> in 0.19. If both are left unset, they default to max_iter=5 and tol=None. If tol is not None, max_iter defaults to max_iter=1000. From 0.21, default max_iter will be 1000, and default tol will be 1e-3.\n",
      "  \"and default tol will be 1e-3.\" % type(self), FutureWarning)\n",
      "c:\\users\\tians\\appdata\\local\\programs\\python\\python37\\lib\\site-packages\\sklearn\\linear_model\\stochastic_gradient.py:128: FutureWarning: max_iter and tol parameters have been added in <class 'sklearn.linear_model.stochastic_gradient.SGDClassifier'> in 0.19. If both are left unset, they default to max_iter=5 and tol=None. If tol is not None, max_iter defaults to max_iter=1000. From 0.21, default max_iter will be 1000, and default tol will be 1e-3.\n",
      "  \"and default tol will be 1e-3.\" % type(self), FutureWarning)\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "array([0.85692861, 0.8780439 , 0.86993049])"
      ]
     },
     "execution_count": 69,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 使用交叉验证评估SGD的准确率\n",
    "cross_val_score(sgd_cif,X_train,y_train,cv=3,scoring='accuracy')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "c:\\users\\tians\\appdata\\local\\programs\\python\\python37\\lib\\site-packages\\sklearn\\linear_model\\stochastic_gradient.py:128: FutureWarning: max_iter and tol parameters have been added in <class 'sklearn.linear_model.stochastic_gradient.SGDClassifier'> in 0.19. If both are left unset, they default to max_iter=5 and tol=None. If tol is not None, max_iter defaults to max_iter=1000. From 0.21, default max_iter will be 1000, and default tol will be 1e-3.\n",
      "  \"and default tol will be 1e-3.\" % type(self), FutureWarning)\n",
      "c:\\users\\tians\\appdata\\local\\programs\\python\\python37\\lib\\site-packages\\sklearn\\linear_model\\stochastic_gradient.py:128: FutureWarning: max_iter and tol parameters have been added in <class 'sklearn.linear_model.stochastic_gradient.SGDClassifier'> in 0.19. If both are left unset, they default to max_iter=5 and tol=None. If tol is not None, max_iter defaults to max_iter=1000. From 0.21, default max_iter will be 1000, and default tol will be 1e-3.\n",
      "  \"and default tol will be 1e-3.\" % type(self), FutureWarning)\n",
      "c:\\users\\tians\\appdata\\local\\programs\\python\\python37\\lib\\site-packages\\sklearn\\linear_model\\stochastic_gradient.py:128: FutureWarning: max_iter and tol parameters have been added in <class 'sklearn.linear_model.stochastic_gradient.SGDClassifier'> in 0.19. If both are left unset, they default to max_iter=5 and tol=None. If tol is not None, max_iter defaults to max_iter=1000. From 0.21, default max_iter will be 1000, and default tol will be 1e-3.\n",
      "  \"and default tol will be 1e-3.\" % type(self), FutureWarning)\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "array([0.90911818, 0.91094555, 0.91013652])"
      ]
     },
     "execution_count": 70,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 将输入进行简单缩放，可以得到准确率90%以上\n",
    "from sklearn.preprocessing import StandardScaler\n",
    "scaler = StandardScaler()\n",
    "X_train_scaled = scaler.fit_transform(X_train.astype(np.float64))\n",
    "cross_val_score(sgd_cif,X_train_scaled,y_train,cv=3,scoring='accuracy')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 错误分析"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 项目流程\n",
    "1. 探索数据准备的选项\n",
    "2. 尝试多个模型\n",
    "3. 选择最佳模型并用GridSearchCV对参数进行微调\n",
    "4. 尽可能自动化"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 确定了一个相对合适的模型，进一步优化，分析其错误类型\n",
    "* 查看混淆矩阵\n",
    "* 使用cross_val_predict()进行预测\n",
    "* 调用confusion_matrix()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "c:\\users\\tians\\appdata\\local\\programs\\python\\python37\\lib\\site-packages\\sklearn\\linear_model\\stochastic_gradient.py:128: FutureWarning: max_iter and tol parameters have been added in <class 'sklearn.linear_model.stochastic_gradient.SGDClassifier'> in 0.19. If both are left unset, they default to max_iter=5 and tol=None. If tol is not None, max_iter defaults to max_iter=1000. From 0.21, default max_iter will be 1000, and default tol will be 1e-3.\n",
      "  \"and default tol will be 1e-3.\" % type(self), FutureWarning)\n",
      "c:\\users\\tians\\appdata\\local\\programs\\python\\python37\\lib\\site-packages\\sklearn\\linear_model\\stochastic_gradient.py:128: FutureWarning: max_iter and tol parameters have been added in <class 'sklearn.linear_model.stochastic_gradient.SGDClassifier'> in 0.19. If both are left unset, they default to max_iter=5 and tol=None. If tol is not None, max_iter defaults to max_iter=1000. From 0.21, default max_iter will be 1000, and default tol will be 1e-3.\n",
      "  \"and default tol will be 1e-3.\" % type(self), FutureWarning)\n",
      "c:\\users\\tians\\appdata\\local\\programs\\python\\python37\\lib\\site-packages\\sklearn\\linear_model\\stochastic_gradient.py:128: FutureWarning: max_iter and tol parameters have been added in <class 'sklearn.linear_model.stochastic_gradient.SGDClassifier'> in 0.19. If both are left unset, they default to max_iter=5 and tol=None. If tol is not None, max_iter defaults to max_iter=1000. From 0.21, default max_iter will be 1000, and default tol will be 1e-3.\n",
      "  \"and default tol will be 1e-3.\" % type(self), FutureWarning)\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "array([[5728,    3,   22,   10,   11,   52,   41,   13,   40,    3],\n",
       "       [   2, 6483,   42,   23,    6,   39,    7,   12,  117,   11],\n",
       "       [  58,   41, 5336,   99,   77,   24,   93,   55,  161,   14],\n",
       "       [  46,   45,  141, 5333,    2,  238,   36,   54,  142,   94],\n",
       "       [  22,   27,   40,   11, 5354,   10,   53,   34,   92,  199],\n",
       "       [  65,   46,   30,  175,   79, 4599,  114,   25,  197,   91],\n",
       "       [  34,   24,   48,    2,   40,   79, 5634,    6,   51,    0],\n",
       "       [  25,   22,   70,   29,   54,   14,    4, 5805,   15,  227],\n",
       "       [  55,  149,   70,  145,   16,  156,   59,   29, 5048,  124],\n",
       "       [  46,   38,   31,   87,  150,   43,    2,  188,   80, 5284]],\n",
       "      dtype=int64)"
      ]
     },
     "execution_count": 71,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "y_train_pred = cross_val_predict(sgd_cif,X_train_scaled,y_train,cv=3)\n",
    "conf_mx = confusion_matrix(y_train,y_train_pred)\n",
    "conf_mx"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAPkAAAEACAYAAABxpdD1AAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjAsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy8GearUAAAKZUlEQVR4nO3dTYid9RWA8edk8mFobc1Qq9SoEOiqxpoyaIWmRLFiFyJtLRZFwbYEi+g60orURQsiboSI40c32i8XLYoWLIVQRaUkSAh+FF0YJBBsTbVV0Dgzp4uMROMk903y/u87c+b5rcbM9T/HSx7fe2fuPROZiaS6Vgw9gKS2jFwqzsil4oxcKs7IpeKMXCrOyDuIiC9GxF8i4umI+FNErB56pi4i4oyIeHHoOY5HRGyPiCuHnqOLiFgXEU9FxM6IuH/oeY5mkMgj4qGIeD4ifjHE1z8B1wH3ZOblwH7gioHn6epuYO3QQ3QVEZuBMzPziaFn6eh64NHMnAJOjYipoQdayNgjj4jvAxOZeTGwISK+Ou4Zjldmbs/Mv87/4+nAW0PO00VEXAq8z6H/KS16EbEKeAB4IyKuGnqejt4GzouI04CzgTcHnmdBQ1zJtwB/nP/4aeBbA8xwQiLiYmBdZr4w9CzHMv904nZg29CzHIcbgJeBu4ALI+KWgefp4lngXOBW4BXgwLDjLGyIyD8H7Jv/+ABwxgAzHLeImATuBX489CwdbAO2Z+Y7Qw9yHDYB05m5H3gEuGTgebq4A7gpM+8EXgVuHHieBQ0R+Xscfp74+YFmOC7zV8bHgNsyc+/Q83RwGXBzROwALoiIBweep4vXgQ3zH08BS+F+XgdsjIgJ4CJgUb4RJMb9BpWIuAH4cmbeHRG/BP6Zmb8d6xDHKSJ+BvwK2D3/R/dl5h8GHKmziNiRmVuGnmOUiDgVeJhDj+xWAVdn5r5j/1vDiogLgd9w6CH788D3MvO9Yaf6rCEi/wLwDPA34LvANzPz3bEOIS0jY48cDv18EfgO8Pf552CSGhkkcknjs+i/6SXp5Bi5VNxgkUfE1qG+9oly5vaW2ryw+Gce8kq+qO+Yo3Dm9pbavLDIZ/bhulRcr99dn5yczPXr13e67YEDB5icnOx02z179pzMWNKykJmx0J+v7POLrF+/nieffLLPIwE455xzej9Tn7ViRZsHdi1/TNvq7IgFe+nFuH9s7cN1qTgjl4ozcqk4I5eKM3KpOCOXiusU+RLcripp3sjIl+J2VUmHdbmSb2GJbleV1C3yY25XjYit879BYueBA4tyI620rHWJ/JjbVTNzOjOnMnOq62vRJY1Pl8h3cfgh+teBN5pNI6l3Xd6g8mfgmYj4CvPbVduOJKlPI6/kmflfDn3z7QXgEtcnS0tLp7eaZuZ/OPwddklLiK94k4ozcqk4I5eKM3KpuF4XOUZEk+VVLXdiLcW9Zq202mu2FO+LlSt7XX/4KTMzM03OPdoiR6/kUnFGLhVn5FJxRi4VZ+RScUYuFWfkUnFGLhVn5FJxRi4VZ+RScUYuFWfkUnFGLhVn5FJxRi4VZ+RScUYuFWfkUnFGLhVn5FJxRi4V1/ve2RYrjlutTQbYvXt3k3M3bdrU5NyWZmdnm5w7MTHR5Fxot+655d+5cavzXyJpQUYuFWfkUnFGLhVn5FJxRi4VZ+RScUYuFTfyxTAR8UXg98AE8D5wTWYebD2YpH50uZJfB9yTmZcD+4Er2o4kqU8jr+SZuf0T/3g68Fa7cST1rfNr1yPiYmBdZr5wxJ9vBbb2PZikfnSKPCImgXuBHxz5ucycBqbnb9fm3QKSTtjI5+QRsRp4DLgtM/e2H0lSn7p84+0nwDeAn0fEjoi4pvFMknrU5Rtv9wH3jWEWSQ34YhipOCOXijNyqTgjl4ozcqm46HPbZURkRPR23jisXNn7wloAdu3a1eRcgPPPP7/JuWvXrm1y7gcffNDkXIBWf99abpidm5vr/czZ2Vkyc8E7wyu5VJyRS8UZuVSckUvFGblUnJFLxRm5VJyRS8UZuVSckUvFGblUnJFLxRm5VJyRS8UZuVSckUvFGblUnJFLxRm5VJyRS8UZuVSckUvF9b6SubfDPn1ui2Ob6vN+PdKePXuanLtx48Ym565Y0e5a0up+bjlzizXgBw8eZG5uzpXM0nJk5FJxRi4VZ+RScUYuFWfkUnFGLhXXKfKIOCMiXmw9jKT+db2S3w20+eXVkpoaGXlEXAq8D+xvP46kvh0z8ohYDdwObBvPOJL6NupFtNuA7Zn5ztFePx4RW4GtfQ8mqR+jHq5fBtwcETuACyLiwSNvkJnTmTmVmVMtBpR0co55Jc/Mb3/8cUTsyMyfth9JUp86/5w8M7c0nENSI74YRirOyKXijFwqzsil4oxcKs7IpeJ639baYstly82nraxatarZ2bOzs03Offzxx5uce9VVVzU5F2BmZqbJuWvWrGlyLrSZeXZ2lsx0W6u0HBm5VJyRS8UZuVSckUvFGblUnJFLxRm5VJyRS8UZuVSckUvFGblUnJFLxRm5VJyRS8UZuVSckUvFGblUnJFLxRm5VJyRS8X1vq31aL/H/GS03NbaYl5YmjO32LQL8NprrzU5F2DDhg1Nzm11XwDMzc01OddtrdIyZeRScUYuFWfkUnFGLhVn5FJxRi4VZ+RScZ0jj4jtEXFly2Ek9a9T5BGxGTgzM59oPI+kno2MPCJWAQ8Ab0REu98mL6mJLlfyG4CXgbuACyPilk9+MiK2RsTOiNjZYkBJJ6dL5JuA6czcDzwCXPLJT2bmdGZOZeZUiwElnZwukb8OfPxWnylgb7txJPVtZYfbPAQ8HBE/AlYBV7cdSVKfRkaemf8DfjiGWSQ14IthpOKMXCrOyKXijFwqzsil4oxcKq73lcy9HTYmrVbvLsWVzK1WBbe0b9++JueeddZZTc4FOOWUU3o/88MPP2Rubs6VzNJyZORScUYuFWfkUnFGLhVn5FJxRi4VZ+RScUYuFWfkUnFGLhVn5FJxRi4VZ+RScUYuFWfkUnFGLhVn5FJxRi4VZ+RScUYuFdf7ttYW208nJiZ6P/Njs7OzTc5tOfNHH33U5NzVq1c3OXdmZqbJudBuK+5zzz3X5FyAzZs3937mzMwMmem2Vmk5MnKpOCOXijNyqTgjl4ozcqk4I5eKO2bkEbEuIp6KiJ0Rcf+4hpLUn1FX8uuBRzNzCjg1IqbGMJOkHo2K/G3gvIg4DTgbeLP9SJL6NCryZ4FzgVuBV4ADzSeS1KtRkd8B3JSZdwKvAjceeYOI2Dr/nH1niwElnZxRka8DNkbEBHAR8Jl3A2TmdGZOzT9vl7TIjIr818A08C4wCfyu+USSerXyWJ/MzH8AXxvTLJIa8MUwUnFGLhVn5FJxRi4VZ+RScUYuFWfkUnG9r2SOWHAr7LLTYjV167NbrU5utTYZYM2aNU3ObblGeteuXb2fee211/LSSy+5kllajoxcKs7IpeKMXCrOyKXijFwqzsil4oxcKs7IpeKMXCrOyKXijFwqzsil4oxcKs7IpeKMXCrOyKXijFwqzsil4oxcKs7IpeL63tb6L2Bvx5t/Cfh3b198PJy5vaU2LyyOmc/NzNMX+kSvkR+PiNiZmVODfPET5MztLbV5YfHP7MN1qTgjl4obMvLpAb/2iXLm9pbavLDIZx7sObmk8fDhulSckUvFGblUnJFLxRm5VNz/AROjPkiRSUZeAAAAAElFTkSuQmCC\n",
      "text/plain": [
       "<Figure size 288x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# 使用matplotlib的matshow函数来查看混淆矩阵的图像表示\n",
    "plt.matshow(conf_mx,cmap=plt.cm.gray)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 看起来不错，大多数图片都在主对角线上，说明它们被正确分类\n",
    "# 数字5看起来比较暗，说明 1、数字5图片较少   2、分类器在数字5上执行效果不如其他数字上好\n",
    "# 假设把焦点放在错误上，为取得错误率，而不是错误绝对值，需要将混淆矩阵中每个值除以相应类别中图片的数量\n",
    "\n",
    "row_nums = conf_mx.sum(axis=1,keepdims=True)\n",
    "norm_conf_mx = conf_mx / row_nums"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 74,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 288x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# 用0填充对角线 只保留错误 重新绘制\n",
    "np.fill_diagonal(norm_conf_mx,0)\n",
    "plt.matshow(norm_conf_mx,cmap = plt.cm.gray)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 75,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 每行代表实际类别，每列代表预测类别\n",
    "# 8、 9列比较亮，说明许多图片被错误的分类为数字8、9\n",
    "# 类别8、9行也偏亮，说明数字8和9经常会跟其他数字混淆\n",
    "# 有些很暗，比如行1，大多数数字1都被正确地分类，一些和8混淆\n",
    "# 5和3是错误最多的"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 结论\n",
    "* 改进数字8和9的分类\n",
    "* 修正数字3和5的混淆"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 如何优化分类器\n",
    "* 尝试多收集这些数字的训练集\n",
    "* 开发一些新特征来改进分类器\n",
    "* 优化分类器算法\n",
    "* 使用pillow或opencv对图片预处理，让显示模型更突出\n",
    "* 分析单个错误"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 76,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 576x576 with 4 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "def plot_digits(instances,images_per_row=10, **options):\n",
    "    size = 28\n",
    "    images_per_row = min(len(instances),images_per_row)\n",
    "    images = [instance.reshape(size,size) for instance in instances]\n",
    "    n_rows = (len(instances)-1) // images_per_row + 1\n",
    "    row_images = []\n",
    "    n_empty = n_rows * images_per_row -len(instances)\n",
    "    images.append(np.zeros((size,size * n_empty)))\n",
    "    for row in range(n_rows):\n",
    "        rimages = images[row * images_per_row : (row + 1) * images_per_row]\n",
    "        row_images.append(np.concatenate(rimages, axis=1))\n",
    "    image = np.concatenate(row_images,axis = 0)\n",
    "    plt.imshow(image,cmap = plt.cm.binary, **options)\n",
    "    plt.axis('off')\n",
    " \n",
    "\n",
    "# 查看数字3和数字5的例子\n",
    "cl_a,cl_b = 3,5\n",
    "X_aa = X_train[(y_train == cl_a) & (y_train_pred == cl_a)]\n",
    "X_ab = X_train[(y_train == cl_a) & (y_train_pred == cl_b)]\n",
    "X_ba = X_train[(y_train == cl_b) & (y_train_pred == cl_a)]\n",
    "X_bb = X_train[(y_train == cl_b) & (y_train_pred == cl_b)]\n",
    "\n",
    "plt.figure(figsize=(8,8))\n",
    "plt.subplot(221)\n",
    "plot_digits(X_aa[:25], images_per_row=5)\n",
    "plt.subplot(222)\n",
    "plot_digits(X_ab[:25], images_per_row=5)\n",
    "plt.subplot(223)\n",
    "plot_digits(X_ba[:25], images_per_row=5)\n",
    "plt.subplot(224)\n",
    "plot_digits(X_bb[:25], images_per_row=5)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 77,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 左侧两个是被分类为3的图片\n",
    "# 右侧两个是被分类为5的图片\n",
    "# 大多数错误分类的图片看起来还是非常明显的错误\n",
    "# 原因：SGD是一个线性模型，他所做就是为了每个像素分配一个各类别的权重，当它看到新的图像，将加权后的像素强度汇总，从而得到一个分数进行分类\n",
    "# 通过上面图像，如果书写3的连接点左移，分类器可能将其分类为数字5，这个分类器对图像位移和旋转敏感\n",
    "# 减少混淆的方法之一，就是对图像进行预处理，确保位于中心位置并且没有旋转"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 多标签分类"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 78,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 为每个实例产生多个类别 ，例如 照片识别多个人脸\n",
    "# 分类器经过训练可以识别小红，小白，小军，一张照片 里有 小红，小白\n",
    "# 经过分类器，应该输出[1,1,0]， 是小红，是小白，不是小军\n",
    "# 输出多个二元标签的分类系统称为多标签分类系统"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 81,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "KNeighborsClassifier(algorithm='auto', leaf_size=30, metric='minkowski',\n",
       "           metric_params=None, n_jobs=1, n_neighbors=5, p=2,\n",
       "           weights='uniform')"
      ]
     },
     "execution_count": 81,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from sklearn.neighbors import KNeighborsClassifier\n",
    "\n",
    "y_train_large = (y_train >= 7)\n",
    "y_train_odd = (y_train % 2 == 1)\n",
    "y_multilabel = np.c_[y_train_large,y_train_odd]\n",
    "\n",
    "knn_clf = KNeighborsClassifier()\n",
    "knn_clf.fit(X_train,y_multilabel)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 82,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[False,  True]])"
      ]
     },
     "execution_count": 82,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 支持多标签分类，不是所有的分类都支持\n",
    "knn_clf.predict([some_digit])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 81,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.977050917084519"
      ]
     },
     "execution_count": 81,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 评估多标签分类器方法很多，方法之一就是测量每个标签的F1分数，或者其他二元分类器指标，然后简单平均\n",
    "y_train_knn_pred = cross_val_predict(knn_clf,X_train,y_multilabel,cv=3)\n",
    "f1_score(y_multilabel,y_train_knn_pred,average='macro')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 82,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 上面假设了所有标签都同等重要，也可以给每个标签设置一个权重（该目标标签实例的数量），设置average='weighted'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 多输出分类"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 例子：构建一个系统去除图片中的噪声，输入一张有噪声的图片，它将输入一张干净的数字图片，分类器输出是多个标签，一个像素一个标签，每个标签多个值0到255"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 83,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 增加噪声，目标将图片还原为原始图片，创建训练集和测试集\n",
    "noise = np.random.randint(0, 100, (len(X_train), 784))\n",
    "X_train_mod = X_train + noise\n",
    "noise = np.random.randint(0, 100, (len(X_test), 784))\n",
    "X_test_mod = X_test + noise\n",
    "y_train_mod = X_train\n",
    "y_test_mod = X_test"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 84,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(60000, 784)"
      ]
     },
     "execution_count": 84,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "X_train.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 85,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "some_index = 5500\n",
    "plt.subplot(121);plt.imshow(X_test_mod[some_index].reshape(28,28), cmap = plt.cm.binary)\n",
    "plt.subplot(122);plt.imshow(y_test_mod[some_index].reshape(28,28), cmap = plt.cm.binary)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 86,
   "metadata": {},
   "outputs": [],
   "source": [
    "knn_clf.fit(X_train_mod,y_train_mod)\n",
    "clean_digit = knn_clf.predict([X_test_mod[some_index]])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 87,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.imshow(clean_digit.reshape(28,28), cmap = plt.cm.binary)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 作业一：尝试使用其他分类来预测MINST数据集"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 88,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.tree import DecisionTreeClassifier"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 89,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1., 0.],\n",
       "       [1., 0.],\n",
       "       [0., 1.],\n",
       "       ...,\n",
       "       [1., 0.],\n",
       "       [1., 0.],\n",
       "       [1., 0.]])"
      ]
     },
     "execution_count": 89,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "tree_clf = DecisionTreeClassifier(random_state=42) # 得到决策值\n",
    "y_score_tree = cross_val_predict(tree_clf,X_train,y_train_5,cv=3,method='predict_proba')\n",
    "y_score_tree"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 90,
   "metadata": {},
   "outputs": [],
   "source": [
    "y_score_tree = y_score_tree[:,1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 93,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 绘制ROC曲线\n",
    "fpr_tree, tpr_tree, threshold_tree = roc_curve(y_train_5,y_score_tree)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 94,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAf0AAAF6CAYAAAATeYHoAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjAsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy8GearUAAAgAElEQVR4nOzdeViUVfvA8e/DvomI4oIguaTivuC+lHuZZVpW7pVLWZb1q963srest7LUrKxMLd/SIiM1M7VcssU1c8Mt09QUEHFDQUAYZub8/jiMILIMCgMM9+e65gIenuWg4j3nnPs+x1BKIYQQQgjn51LaDRBCCCGEY0jQF0IIISoICfpCCCFEBSFBXwghhKggJOgLIYQQFYQEfSGEEKKCkKAvhBBCVBAOD/qGYdQwDGNjIefMNwxjq2EYLzmqXUIIIYSzc2jQNwyjCrAA8C3gnMGAq1KqE1DPMIybHdU+IYQQwpk5uqdvAe4Hkgs451bgm6zP1wJdS7hNQgghRIXg5siHKaWSAQzDKOg0X+Bk1ueJQJvcJxiGMR4YD+Dr69u2cePGxdtQIYQQKAUWC7jliBRpaZCeDgEB4OKSfezyZfD1BS8vfSwxEVJT9bHAQH3MYoG4OH1daGj2PQ8fBrMZGjbMflZ8PFy4AMHBUKWKbkt8PJw9q78OC8u+Z3S0vq5ly+x7Hjig29mkCXh762N//w3JyfraatX0sbNnISZGf227Z0oKHDoEPj4QHp59z5079cc2bcAwdJsOHdI/Z+3aULOm/v6pU3D+PNSqBVWrAtZM0i5lknTehK+XCX9fE1gywZyB1ZyJC+ZC/y7Sra4cPZ9Juhl8PV1JzbCcU0oFFXphLg4N+nZKAbL+ivAjj9EIpdQ8YB5ARESE2rFjh+NaJ4QQdkpKgj179H/8TZvqY1Yr/PyzDhq9emWfu307nDkD7dpB9er62Pr1sGUL9OwJXbroY8ePwyef6AA1frw+phSMHavv/dln2fd8+mn9/Pffh+bN9bEZM+Cjj+CZZ2DiRH1szRoYMAD69oVVq/SxzEzw8NABMy1NHzt2DBo00M/buzf7nk89pZ/x7rv688xMWLhQt+mhh+B//9PnnT2rf7Zq1SDnf9s1a8Lp0/DjjzpQAowbB59+Cv/+t/45LRbdtoEDoV8/+PJLfd7Fi/pNgNkMq1dnB/Nu3eCvv+Cbb7L/7KdPhwUL4NFHs3/2TZsgKgq6doX778/+e5s1Czp1gt69s9v5++/6DUu7dvrvDyDueDq+lpNUVjG4JMdBUhwkxerXxVhIPgkWUz7/Qlz1y9UTKofoV0AoVA7N+lp/XH7wEnd30/3fm265hy3LvyA4wOdEPjctUFkM+jvRQ/q/Ay2BQ6XbHCFERRYTo3ucYWG6dwvwxx+weDHccQfceqs+tmyZDnx9+sDkyfrYnDnw/PPQv392MLVa9TmurjpQ2fznPzr4/vAD3H67PrZ2LUybpoOvLejHxcGbb+qvbUHfMLID6/z52T3wXbtgwwbd67ZJStJvHC5cuPrnNJuvbo+7uw74ly9nH6tXD+67TwfJ1NTs4xERMGIENGqUfW2XLjBhAgwalH1epUowb152z9tm7Vod1G0BG+DVV/WbFtubAFdX/ebnzBndA7epXBkyMnRP3yVHF3FjHunizz2nXzl17apfOVWurP8+UApSE68E8Y7EwYU4+CYmK7jHEZJ65toH5eYdmCOYh14b4H2Dst9F5JCamsri6DO8tuokldreSY9+A1j0ykP4eFx/6C7VoG8YRhNgmFIqZ5b+d8BGwzCCgduBjqXSOCFEmWKx6P/Ubf83pqfrl7c3eHrqYzExcPCgHjpu0kQfO3tW924bN9a9Ttu97r4bTpzQPVbQvcpp0/Q916+Hm7NSiJ95BpYs0YHuvvv0sTVr9D1r1dI9SldX3bbfftPDx7agf/vt8NprUKNG9s/h4qKDl6vr1T9fu3b6ezkDX8+eOuB36pR9LCwM/vvfq4fHbe13yTUuOmOGbk+LFtnHnnoKHn5Y945t+vQBk+na6209/Jy+/lq/choxQr9yatwYZs+++piXl+7B55azfTbBwfqVk5+ffuVkGPrP6LpYMnVPPClO98pz9tKzgjqZefwh5OTiBv7BULlOjkCeFdQr14HKtcEj39z1fEUtXsLwYcPwaXUHgb3G8sqb03i6d0NcXAqcHi+UURa31s3K8u8DbFBKJRR0rgzvC1G22HqMbm7Z87PHj8P+/XDTTdCsmT729dfwxRd6iPv//i/72nvu0QHx22/1sV27oHt33bOMj792+HfevOxAMmsWTJqkh24/+EAfi46G1q2hY0c9/Fu5su5tu7qCv78e3m3eXM8rb9yoe8+7d2cHomefze5x33abPrZ2LaxcqXu4w4freyUkwNKlOni3b1+Sf8LCbulJeQdz27FLp4BCYqBn5VzBPMfHgFDwqwEurgXfowisVitD7n+Ab5csBsOgao+HmP/OawxsVfuq8wzD2KmUiijq/cvi8D5KqQtkZ/ALIUrIsWNw9KjuNdryYVNSYN06PYTar1/2uZMn62Htdev019u3695yfPzVwXjCBB2M587NHn5evlz3MCdNgvfe00HXxUUPZZ84kR30Ab7//upecIsWOhEsNRWOHMl+jo+PDto5k8zCwnSv1TbMDHoOecIE/TxbL9HFBRYt0r1EW/JWw4Z6+PnYsexngO4t59a3r37lVLMmPP54/n/WophZLXApIUevPDZXgI+DjIIKxQDDBSoFXx3MA3INwXtVdszPAxw9epTOXbtxJuEULt7+NB7zDl8+dw+t61Qp/GI7lcmgL4TIn1JXT/9dvKgzhYOD9VD3+vW6x5uSonu7TZroHu6wYXqod+5cGDNGX7typQ7ETz6p56NBJ1QNHgx16+oAaDN1qn728eO6xx4RoYO9rU027u56uD3nUHGDBno+2JYJ7eKie++jR8O992af5+qq58ZzXuvmBlu36mQ4W2Y46Pba2mwzcKB+5RQcfO0wM8ADD1x7LGewF6XMlJqjV54rmCfFQnI8WAvJenf3yRXMQ66eV/cPBld3x/w8dnjhv9M4k3AK7/rt6Dbhbf43piO1A7wLv7AIJOgL4UCHD+th4Jtugjp19LG//oK33tLzv7bs4UuX9LB3u3Y60xp0FvfYsXrO2mrNLhmqU0efv3GjTki6fBk6dNA984sX9bVduuhe9YABVydr1asH9evrXq6Nn5/uweechwZ4553s54L+mJmpA3XONyGzZ18bZO+4Q79yqlkTPv/86mOGoZ+dW+3a1x4T5ZjVCqln8xl2z/r8cmLh9/GrkWP+PPTa3rp3lTwT5MoSk8nE4sWLsdbrws7ggVQfWpeBt/Xm3ftb4etZ/CG6TM7pF4XM6YvSYPu1MQxd+/vpp3oeePFiPWcMei74iy/0q29fnWT29ts6IL79NvzrX/q8hQt1j7dnT91LB92DtgU627PMZt2LBvjpp+xyr6FD9fz4li3ZCV9Hj+p2deyYnXFuC/a5g7QQxS4zPStBLtccepIt6/0kWDIKvoerx9XB/KoEuVDwrw3uXgXfo4zbsWMHvXv3ISnpIjVGTMerdjiP3VqfZ/s2KjRhz6nm9IVwtKQkPdTt63t1T/OBB/Tc8dy52QG3alVdAnX0qO4pHzmiA/66dfqjrYQrIUGXF6Wk6K/r1NFD7f7+V2clt2+vE8/q188+FhSkh65tWemgh7n/+UdfnzPzetEi/cqpfv2r72e7XogbphRcvgAXs8vWrqpLT4oDe8vYKodAQJ28E+R8ql1bTuBEXn75ZV5//XWUUvi26INfSDjThrRkcJuQEn2u9PSFU1NKB9/Tp6FVK30sMlKXF7VrpxPTQPeSu3TRSV/x8dmJZL6+umzp4sXsHnznznqOef163TsHnZm+YoXOPLcNlR89qkcxw8JuoKRICEezZOr58jwT5GxlbKkF3+NKGVs+demVQ66rjM0ZWK1WIiIi2L17Ny5uHlS7+0VCWnRm3qi2tA0LtPs+0tMXFd6yZbrHW7UqfPyxPrZ5s66jbtAA/vxT99ZvuUV/79QpPcfesKEO5H5+Oos9Z+b49Ol6WD5nj3vZMp1QVjlHUm+zZtmlaDa5e9pClAnpSdnB+0pvPUdQv3QKlLXge3j6F5wgV6lmsZaxORMXFxcuZ1rxqlGPoAfepMlNtfh0dAQhVXwKv7gYSE9flEtHjuiktaAg2LdPHzt8OLtUy/bP2laP7eamg3etWnphliNH9Jx57oU+hCjXrpSx5VOXnhQHGUmF3MSASrXyr0t3cBmbM7BarTzyyCNERETg1+o2/rNsH1YMeodX570HWuN3HQl70tMXTiM1Va+S1rSpnr8GPTS/Zw/ExkJIiJ4TN5v1sPqZM3pYvmFDeOIJuPPO7Hu5uFxdTgb6TUDOOm4hyg1bGVtewTwppghlbPnVpYeWuTK28i4+Pp4uXbpw/PhxlqxYTeUHQwCDR26px7/6Ncb1BlfYKyoJ+sJhTCY4eVL3zm097Dff1LXk332ny8zi43V9uMmkNyXp0UP3zIOy9pL6/nt47DGdXDdvni77qlo1+xmzZjn+5xKiWCily9jyq0u/GGtfGZtv9Xw3biGgTrkoY3MWCxcuZMyYMZjNZmqGt8O9/wu4uxq8Oag5QyJCC79BCZCgL0rEl1/qRLd//1uv9Hbpki4nO3BAL2Hap48+b8cOnWgXHa3Pq1VLr572/vvZc+uurnpVtIwMvZyqzeDBjv+5hLhu5oxc2e65F56JK0IZm21d91wJck5QxuYsPvvsMx5++GFcXV1pNGgS6Q37EOjrwdyRbWl3k/0Je8VN5vTFDfv8c71d5ZNPZu+o1aWLzoifMUNvWALZa6W//nr2hiTbtunh+caNszc4sViu3YxEiDLNVsZ2TTDPEdBTThd+H+8q+dSlZwV43yCnLmNzBmazGTc3N0wmE51u6UVq+4dJ965Owxp+zB/djtDA4knYkzl9USLS0/XcuW04/qOP9JaXU6boYXbQpWm//nr18qePP65Xncu5e9a8eXof8Jw6dLj2mRLwRZlzpYwtx/z5lQz4WPvK2AxX3RPPL0HOvzZ4SmZpeTZt2jReeeUVNm/ezN+WaiT1eAGzVdGjURCzhramklfp50pI0BeAXmxm6VIdqG1D7/fco3c6e/ppmDlTB39/f71VaVRUdtC/5x6daNcxxybIw4bpV04yjSjKrPTkvBeZsR2zp4zNo9K1m7XkXHhGyticVlpaGr169eL333/Hw8ODmcu3sSlDr7M9tmtdXugf7vCEvfzI8H4FtHy5HmLv2xfeeEMfW7NGbxuacynY7dv1anG+vtmryp04oReh6dwZ2rQpnfYLUSRWix5az68u/WKs/WVs+dWlB4RKGVsFtWHDBvr3709qaioNGzaizeOz2BqfiZuLwRuDmnF/uzol8lwZ3hf5io7W5W6jRunedkCATqCLidHD8MHBennYm26CatWyr2vaVNfA51x0JixMLxkrRJlhSiugLt22G1tmwfdw884/mFcO0duvusmyiuJaY8aMITU1lYcffZzYhkPYGp9CFR93Ph7Rlo71qhZ+AweToO+EzpzRQ/HBwbqHPmmS3ic8IUEPyXfvDr17w0MPZW8lGhqq13XPycfn2lXmhHAoWxlbXsHcdiztfOH38Q26umwt985sPoEy/yTsdu7cOf755x/atWvHTz/9xOrf9zH3sCeJp1NoUN2P+aMjCKtaNpcZlqBfjmVkwO+/68Vs+vfXX1evrvdM/+9/9S5vfn56GH7NGp005+en/29bt660Wy8EucrY8umt21PGdiVBLo85df9gcC/ePclFxbV06VKGDRuGm5sbSUlJ/HHWhRl7Xci0mLilYRAfDGuNfxlI2MuPzOmXM7aNXwwje5OY1q1hwwbdM9+/H/r10738NWuuHq4XwqFyl7FdNaeeFeDtLmPLpy69cqiUsQmHsFqtDB8+nK+//hoXFxdef+NNaHEXczccA+DhLnV5sX9j3Fwd829R5vSdXFqazo7ft09vFFOzpp6Db9Qoe135Jk10iVxsrGyjKhzAYoZL8fnXpV+Mtb+M7aoEuVwBXsrYRCmLiYmhY8eOnDp1imrVqvHD2vXM3ZvBTxuO4eZi8OrApgzvEFbazbSLhIYyav9++OorPTR/7726F9+zpw76a9fqpLzgYPjrr2uvlYAvisWVMrYcdek5S9kuxRehjC2fjVv8aoKr/IMVZZufnx8XL15kwIABzJofyYSvovkr4RKVvd35eEQbOtcvP0Oq8ttWRmRmwhdfwMMP66+3bIGpU3V2ff/+OuiPGwf/+c/Va80LcV2sVkjJsRtb7rr0pFi9BWuBbGVs+WzcYtuNTRLkRDlkMpl44IEH+PDDDwkODiYxMZH9CWncO3cb51NN1AvyZf7odtStVjYT9vIjQb8MiIvT2fPVqukNZurWhV69oGVL3dN3z8oJadq0dNspypGrythy16XH2F/GVlBdupSxCSe1fft2+vTpQ1JSEt7e3kRGRvLDn+d4fuk+TBYr3W6uxofD2lDZu+wm7OVHgn4pMpv1ULyvry6lmz0bNm/WQb9+fV1fL8Q1lILUc3lkuucI8HaXseVTl165jpSxiQrpP//5D2+88QZKKcaOHcvHH8/h7dV/8fGvRwEY3SmM/wxo4rCEveImQb8UJCbqIfovvtDz9VWq6GH8Z56BevVKu3Wi1JkzIPlkrjn0nFnvcWBOL/getjK2/OrSK9eWMjYhcrnvvvtYvHgx3t7eLF26lO49+/DYV7tZ++dpXF0MptzZhJGdbirtZt4QCfoOopTePc7NTa+IV7cujBwJP/4IkZE6815UAFfK2AqoS085DRRSSusVkP9+6ZVD9J7qUsYmRJFMmjSJEydOsG7dOi5Z3bl3zlYOnkrG38uN2cPb0vXm8pOwlx8J+g6wfLkO8PPn6zn6+vXhpZf0x1tuKe3WiWJlMevNWa4E8lx16UlxYEop+B6Gq15Q5qpFZkKv7qV7VnLMzyOEE7NarYwfP561a9dy7NgxunTpwrZt29gVc4HxC//gXEoGdav58unoCOoHOUfpqAT9ErJrl0688/TUC+fceSfcdx98/bUO9rYsfVHOZFwquC7drjI2v/z3Sw8IlTI2IRwgLi6Orl27cuLECQICAkhISCAkJITl0Sd5bsleTGYrXRpU5aNhbQjwcZ6EVfmfpQRMngxvvgk//6yz8d95B77/Xh+XYfwyzGrN3o0tr7r0pJgilLHlU5deOUQPzUuCnBClZsGCBYwdOxaz2UyvXr344YcfcHNzZ8aaQ3z4yxEAhneow5S7muJeThP28iNBvwS0aqU/fvONDvoAd91Veu0RWUxpWQly+dSlJ520o4zNK//90iuH6OQ5KWMTosxKS0tj7NixKKWYPXs2EyZMIM1k5snIXaw+kICLAa/c2ZRRncIwnPDNuQT9YhAdDXPmwAcf6Jr6W27Re9FHFHlVZHHdlNJlatfsl54jwKedK/w+PtUK2GI1FHyqSi9diHLo4MGD1K1bFx8fH7788kvat29P3bp1OZV0mbELdnAgPplKXm58NKwN3RsGlXZzS4xsuHOD0tJ0nT1A48bw558SE0qE2ZTdS8+rLt2eMjYXd50El19dupSxCeGU3nrrLSZPnkyXLl3YsGHDlePRsRcZt3AHZy9lEFbVh/mjI2hQvXwkycqGOw6mFJhMenlckwmefx769pWAf12UgvSL+e+XfjHW/jK2axLkQrOPSRmbEBVKWloaPXv2ZNu2bXh4eDBp0qQr3/t+TzzPLd5DhtlKx3qBfDy8LVV8nX9qToL+dbBawdUVZsyASZP0kP4775R2q8qwK2Vs+dSlJ8UWoYwtJJ859RApYxNCXLFhwwb69+9PamoqjRs3ZuPGjVSrVg2rVfHe+r+Ztf5vAIa2D+XVu5rh4VYxOgQS9K/Dzp263v7ZZ/Ve9j17lnaLSllGSsF16cnxoCwF38NWxpbfWu+VakkZmxDCbrGxsaSlpfH0008zc+ZMAC6bLDy7eA+r9p3CxYDJdzTh4S43OWXCXn5kTv86PfusXl3vrbcc/mjHsloh9Uz+delJsXpovjB+NfOvS5cyNiFEMThz5gxTpkxh9uzZAJw7d45q1fQqeglJ6YxbuIN9J5Pw83Tjg2Gt6dGoemk294bInL4DfPkltG0L4eEwfbqTxKjMy7pULefa7lcFeHvL2PKrSw/Vw/Juno75eYQQFdKSJUsYPnw4JpOJfv36MXDgwCsBf19cEmMXbud0cgahgd7MH92OhjUq5nSgBH077dunl9IdMQI++0z38ss8WxnbNXXpORaesbeMLb/90iuHgm81J3kHJIQob6xWK8OGDSMqKgoXFxemTZvGwIEDr3x/1d5TPLM4mvRMK+1vCmTOyLYEVoCEvfyUh9BVJly4oHfEO3y4DAX8K2Vs+dSlJ8WB+XLB97iqjC2Ea+rS/WuDh49jfh4hhCiim2++mWPHjhEUFMQvv/xC06ZNAVBK8cHPR5i57jAAQ9qG8Mag5hUmYS8/ZSV8lVlpaXr9/O7d9dC+q6uDHqyUXvK1oLr0SwkUXsZWOXv+/Jq69BDwqw4ujvqhhBCiePXr14+TJ0+ydOlS3LJ6ZOmZFp5bspcVe+IxDHjx9nDGdqtboRL28iNBvwAWC3Trpkvzbr01exGe4rm5GVIS8t4v3XbMdKngexguUKl2/nXp/rXBy78YGy2EEKXLZDJx2223ERISwsKFC68k7dmcSdYJe3vikvD1cGXW0Nb0Cq9RSq0teyToF2DePL1b3pQpesOcypWLcHFGSsF16faUsbn75ppHz1WXXilYytiEEBXG9u3b6dOnD0lJSTRu3Pia7+8/mcS4hTs4lZROSBVvPh0dQeOa0vHJSSJGASZMgBMn4KabcgV8WxlbnnXpWXPq9pax5blfetYx7yqSICeEEMDkyZOZOnUqSinGjRvHvHnzrvr+6v2neDpqD5czLUSEVWHOyLZU85Oqodwk6Odh7650GteMw+NyLG8OicUlOQ6+yxHgk0+CxVTwTa6UseVTl+5fW8rYhBDCDitXruTNN9/E29ubZcuW0a9fvyvfU0ox+9ejTF9zCIB72oTw5uBmeLpJrlJeKl7QVwrSEvPYL1330tMS4mhhPXvl9HzzPH2q5r9feuU6UsYmhBA3KCYmhjp16jBgwABeeOEFnn/+efz9s4fr0zMtPL90L99F64S9f9/WmEe615OEvQI4d9A/fxT2f3ttgC+gjM0HyLS6cTajNrUa18EIyJkgl+OjlLEJIUSJsFqtjB8/nvnz5zNnzhweeeQR3nzzzavOOXspg/Ff7GB3zEV8PFx57/5W9G1as5RaXH44d9BfMQmOb7z2uFfla+fPcyTMWdxqEOwjQ0NCCOFocXFxdO3alRMnThAQEEDbtm2vOefP+GTGLthOfFI6tQO8+WRUBE2CJWHPHs4d9FOzVpu75Xmo3TY7wOdRxnb+vB6ND/QHLwc3UwghBCxYsICxY8diNpvp3bs3q1atwsPj6tXz1h5I4KmoaNJMFtrUCWDuyAiCKkl+lL2cO+hbMvTHFvdB1foFntqzJ5jN8Pjj8NhjDmibEEKIq0RGRurEvNmzmTBhwlXfU0ox57djTFvzF0rBoNa1mTq4OV7uMipbFM4d9M1ZQd+18HWW69SBlSt1j18IIYRj7N+/ny1btjB+/HhWrlzJqVOnCAsLu+qcDLOFF77dx7e7TgLwXL9GPHZrfUnYuw4VI+i7FT5gv2IFbN0K7duXcJuEEEIAMHXqVF566SUMw2DYsGH4+fldE/DPpWTw6Bc72XHiAt7urrx7f0tua1arlFpc/jl30LfV0rvl39NXCjIzwcMDOnVyULuEEKICS0tLo2fPnmzbtg1PT08iIyPx8/O75ry/EpIZ8/kOTl68TK3KXnwyKoJmtYuyNKrIzbmDvjldf3TNP8ljxgw4dQpmznRQm4QQogKLi4ujcePGpKam0rhxYzZu3Hhl3/uc1h88zZOLdpNqstAyNIBPRralur+kWd8o5w36SuXo6ecd9A8dgn/9S39+333QsaOD2iaEEBVUcHAwtWvX5o477mBmHr0tpRSfbDzG1B91wt6dLYOZfm8LSdgrJs4b9G0B39Uj35XxGjbUgX/uXOjQwYFtE0KICuTMmTP06tWLmTNn0qdPHw4dOpTneSazlcnL9rF4ZxwAz/RpyMSeDSRhrxjlu8psuWfH0L5h6MD/zjuyYq4QQpSEJUuWEBoayv79+/n888/zPS8x1cSIT7exeGccXu4uzB7ehid63SwBv5g5cdAveGh/7VqIi3Nge4QQogKxWq3cd999DBkyBLPZzIwZM4iMjMzz3MOnLzHwo038cTyRGv6eLH6kM/2bS4Z+SXB40DcMY75hGFsNw3gpn+9XMQzjB8MwdhiGMfe6H2Tr6ecR9JWCfv2gaVN4993rfoIQQoh8jBgxgsWLFxMUFMT+/ft55pln8jzvl0NnGDx7C7GJl2kRUpnvJ3aleYhk6JcUhwZ9wzAGA65KqU5APcMwbs7jtJFApFIqAqhkGEbEdT0s55x+LmfOwJAhkJwMY8de192FEELkITk5GYAPP/yQBx98kISEBMLDw685TynFpxuPMebz7aRkmLmjRS2ixneihmTolyhH9/RvBb7J+nwt0DWPc84DzQzDCABCgdjrelIBC/PUqAHffAMWC1SqdF13F0IIkYPJZKJHjx4EBQURHx9PYGAgn332GS4u14YZk9nKi8v28fqqg1gVTOp1Mx8ObY23h2TolzRHB31f4GTW54lAjTzO2QSEAU8CB7POu4phGOOzhv93nD17Nu8nXRnev7qnb7XqunyAPP4tCiGEKKLt27dTvXp1fv31V2rXrl3guRdSTYycv41Ff8Ti6ebCB0Nb83SfhpKw5yCODnspgHfW5375PP8V4FGl1GvAX8BDuU9QSs1TSkUopSKCgoLyftKVGv2re/pjx8LkyXpeXwghxI158cUX6dChA0lJSYwbN45jx44RHByc57lHzlzi7tmb2fZPItUrefLNI524s2Xe54qS4eigv5PsIf2WwPE8zqkCNDcMwxXoAFxfeM5js52MDIiJgc8+g3DuX4AAACAASURBVD//vK67CiGEyGI2m/nwww/x8vJi9erVzJs3L99zfzt8lkEfbeHE+TSa1fZn+cQutAwNcGBrBTg+6H8HjDQMYyZwH3DAMIzXc50zFZgHJAGBwKLretKVOf3s7H1PT5g6FW67TWfuCyGEKLoffviBgwcP4ubmxtatW0lISKBfv355nquU4vPN//DQZ39wKcPM7c1q8s0jnahV2TvP80XJcuiKfEqpZMMwbgX6ANOUUgnAnlzn/AHceEi25J3I166d3lFPCCFE0VitVsaMGcPnn39O3bp1OXbsGE0L6EFlWqxM+f4AkdtiAHiiZwOe7t0QFxeZvy8tDl+GVyl1gewM/pKTx/C+2QxubvolhBDCfjExMXTr1o2YmBgCAgJYsmRJgedfTDPxWOQuthw9j4ebC9PvbcHAVgUn+YmS57z567mG93/9FcLD4dVXS69JQghRHi1fvpz69esTExND7969OX36NG3atMn3/KNnUxg0ewtbjp6nmp8nUeM7SsAvI5w36FuuDvoffwxHjkDs9VX9CyFEhdWwYUO8vLyYM2cO69atw8Pj2kXPbDb+fZZBH23mn3OphNfSCXut61RxYGtFQZx3oNu29n7Whjtffw3PPluK7RFCiHJk//79PPzww2zYsIHw8HCSkpLyXGgnpy+2HmfKij+xWBV9m9Tg3ftb4evpvGGmPHLenn6uxXkMQyfxtWtXim0SQohyYOrUqbRo0YLt27ezaJEuoCoo4JstVl5evp//LD+Axap47Nb6zBnRVgJ+GeS8fyM5Fuc5d06vvhcYWLpNEkKIsiwlJYWePXuyfft2PD09WbRoEYMGDSrwmqS0TCYu2sXGv8/h4erCW/c0Z3CbEAe1WBSV8wZ9W0/f1ZNp02D1anjiCRg3rnSbJYQQZVWzZs04ceIE4eHhbNiwgWrVqhV4/j/nUhmzYDvHzqZS1deDeaPa0jZMeldlmRMHfVsinwc//gj790MVySURQohrmEwmPDw8eOONN4iOjmb69OmFXrPlyDkmRO4i6XImjWtW4tPREYRU8XFAa8WNcN6gn2N4f88eiI6Gli1Lt0lCCFGWnDlzhq5du+Lu7s6BAwcYPnw4w4cPL/S6yG0neGX5AcxWRe/w6rz3QGv8ZP6+XHD+RD5XD1xcoE0bcJVdG4UQAoBvvvmG0NBQ/v77bwICArBarYVeY85aYW/ysv2YrYpHbqnH3JEREvDLEScO+rqnb3X1LOREIYSoOKxWK0OGDOH+++/HbDYzY8YMNm/eXGg5XnJ6Jg8v2MHnW47j7mow/d4WvHB7OK6ypG654rxvz7IW5xk60pN9Vr0iX/XqpdskIYQobTt37mTJkiUEBQXx22+/ER4eXug1J86nMmbBDo6cSSHQ14O5I9vS7iZJ2CuPnLinr4N+htmTgwchKKiU2yOEEKVo2bJlWK1W2rVrx4oVK0hISLAr4P9+7DwDP9rMkTMpNKzhx/LHu0jAL8ecPuh/860Xf/2lF+cRQoiKJj09nVtvvZXBgwfz2GOPATBgwIBCh/MBorbHMOLTbVxMy6RHoyCWTuhMaKBk6JdnTjy8r+f0Pbw9aFS3lNsihBClYNu2bfTt25fk5GTq1avHyy+/bNd1FqvizR8OMn/TPwCM7VqXF/rL/L0zcOKevs7ez7BIIp8QouKZMmUKnTp1Ijk5mUceeYSjR48SHBxc6HWX0jMZu2A78zf9g5uLwdv3NOelAU0k4DsJJw76enh/0jOebNxYym0RQohS4O3tzdq1a5kzZ45d58ecT+Oej7fwy6GzVPFx58uxHbi/XZ0SbqVwJOcN+lnD+xu3euIjU1BCiApg5cqVPPzww4Du6V+4cIE+ffrYde0f/yRy9+zNHD6dQoPqfnz3eBc61qtaks0VpcB5g37W8P7/PveQlfiEEE7NarXy4IMPcuedd7JgwQISEhIACtz3PqfFO2IZ/unvJKaa6N4wiG8f60xYVd+SbLIoJc6byJe1OE+HLl7O/FMKISq4mJgYunbtSmxsLFWqVOGnn36iZs2adl1rsSqmrf6LuRuOAfBQl5uY3D8cN1fn7Q9WdM4bDm3L8LpJIp8QwjklJyfToEEDMjMz6du3LytWrLC7d5+SYeapr3fz08EzuLkYvDqwKcM7hJVwi0Vpc9q3c5npuqe/4kf7fgGEEKK8sK2T7+/vz7333sucOXNYs2aN3QE/NjGNez/ewk8Hz1DZ252FY9pLwK8gnDbo25bh3XfQq5QbIoQQxWfv3r1Ur16d1157DYCvvvqKRx55xO7rdxxP5O6PNvNXwiXqBfny3eNd6Fy/Wkk1V5Qxzhn0rVbcXTIBuHuweyk3RgghisfUqVNp1aoV58+fJz4+vsjXf7srjmGfbON8qoluN1dj2WNdqFtNEvYqEuec08/q5ePqSZOmsqCEEKJ8S0lJoWfPnmzfvh1PT0+ioqIYOHCg3ddbrYrpaw/x8a9HARjdKYz/DGgiCXsVkHMG/ayFeXCToX0hRPn38ssvs337dpo0acLGjRsJDLR/w5vUDDNPR0Wz9s/TuLoYTLmzCSM73VRyjRVlmlO+zdu9I2uHPYsk8Qkhyq+tW7cCMGPGDObMmcOBAweKFPBPXrzMvXO2svbP0/h7ubHgofYS8Cs4pwz60VlB/2KK9PSFEOXPmTNnaNiwIZ07d2bDhg24uLgUKVkPYFfMBQZ+uJmDp5KpW82XZY93oevNkrBX0Tll0G/eRJfr+QVIT18IUb5ERUURGhrK33//TZcuXWjfvn2R77E8+iQPzPudcykZdGlQlWWPdaZ+kF8JtFaUN04Z9CNa6oV5fP1lYR4hRPkxZMgQHnjgAcxmMzNmzGDTpk14edk/Ymm1KmasOcSkr6Mxma0M71CHzx9qT4CPdICE5pSJfOaMDP2DyWp8QohyZP/+/VSvXp1ff/2V8PDwIl2bZjLzf1F7WH0gARcDXrmzKaM6hWEYUsEksjll0I9caGI0oFw9kX/uQoiy7P3336d69eoMHTqU7du34+Pjg4tL0QZhTyVdZuyCHRyIT6aSlxsfDWtD94ZBJdRiUZ45XdBPT4cvPktn9CjAVYa0hBBlU3p6Ov369WPDhg0EBQUxdOhQ/PyKPu8eHXuRcQt3cPZSBmFVfZg/OoIG1SuVQIuFM3C6oJ+WBnf004l8hrtk7wshyp5t27bRt29fkpOTqVevHhs3bryu+3y/J57nFu8hw2ylY71APh7eliq+0tkR+XO6RL7AQHhqYtYOe9LTF0KUMcuWLaNTp04kJyfz6KOPcvToUYKDg4t0D6tVMXPdYZ5ctJsMs5Wh7UNZ+HAHCfiiUE7X0wcwLLqnL4l8Qoiy5vbbbyc8PJz33nuPPn36FPn6yyYLzy7ew6p9p3AxYPIdTXi4y02SsCfs4nQ9/S1b4GyCLMMrhCg7Vq5cSVBQEIcOHcLLy4sDBw5cV8BPSErnvrlbWbXvFH6ebsx/sB1jutaVgC/s5nRBf8IEeHmyDO8LIUqf1WrlwQcf5M477+T8+fNs2rTpuu+1Ly6JgR9tYt/JJEIDvfn2sc70aFS9GFsrKgKnG95v3x4898nwvhCidMXExNC1a1diY2OpUqUKP//8M61atbque63ae4pnFkeTnmml/U2BzBnZlkCZvxfXwemC/iefQNq6DNiMBH0hRKnp168fsbGx9O3bl1WrVuHmVvT/bpVSfPDzEWauOwzAkLYhvDGoOR5uTjdIKxzE6YI+gI971py+qwR9IYTjmM1mYmNjqVu3Lt9++y0bN25k/Pjx13Wv9EwLzy3Zy4o98RgGvHh7OGO7yfy9uDFOFfTT0uDECQg32xL5JOgLIRxj79699OjRg8zMTM6cOUN4eHiRl9K1OZOczriFO9gTl4SvhyuzhramV3iNYm6xqIicaoxo/Xro3h2+jpQ5fSGE47zxxhu0atWKxMRE7rrrLjw8rn++ff/JJAZ+tJk9cUmEVPFm6WOdJeCLYuNUPf1Ll+DcOfD3sWXvS9AXQpSclJQUevTowY4dO/D09CQqKoqBAwde9/1W7z/F01F7uJxpISKsCnNGtqWan/w/JoqPUwX9+++H/v3Be10GHEB6+kKIEpWcnMyePXto0qQJGzduJDAw8Lruo5Ri9q9Hmb7mEACD29Rm6uDmeLq5FmdzhXCu4X1XVwgIAE9XGd4XQpScF198kcTERIKDgzl27BgHDhy47oCfnmnh6ahopq85hGHA87c35p0hLSXgixLhVD39K8yyOI8QovglJCTQrVs3jhw5wt69e1m5ciUhISHXfb+zlzIY/8UOdsdcxMfDlffub0XfpjWLscVCXM2pevpPPAGDBkFSoq2nL8vwCiGKR1RUFHXq1OHIkSN069aNJUuW3ND9/oxPZuCHm9gdc5HaAd4sebSzBHxR4pwq6K9cCd99B5mXs3r6btLTF0LcuEmTJvHAAw9gsVh455132LBhA15e19+pWHsggXvnbCE+KZ02dQL47vEuNAn2L8YWC5E3pxre/+YbWL0a/H1NkIRk7wshisWAAQNYtmwZ69ato1GjRtd9H6UUc347xrQ1f6EUDGqtE/a83GX+XjiGUwX9du30i09klz0hxI15//33+d///sfu3bvp06cPMTExN3S/DLOFF77dx7e7TgLwXL9GPHZrfVlhTziUUwX9K66syCfD+0KIoklPT6dfv35s2LABd3d3/v777xvq3QOcS8ng0S92suPEBbzdXXn3/pbc1qxWMbVYCPs5TdBPToa5c6FmTRhpkbX3hRBFt23bNvr27UtycjL169dn06ZN1Kx5Y8l1fyUkM+bzHZy8eJlalb34ZFQEzWpXLqYWC1E0TpPIFxcH//oXvP46OXr6EvSFEPYxmUx069aN5ORkJkyYwJEjR2444K8/eJp7Zm/h5MXLtAwNYPnjXSTgi1LlND19f3947jm9OI8EfSGEvS5evIiPjw8eHh5Mnz6dZs2a0atXrxu6p1KKTzYeY+qPOmHvzpbBTL+3hSTsiVLnNEE/JASmTcv64m0Z3hdCFG7lypUMGTKEW265hdWrVzNp0qQbvqfJbGXysn0s3hkHwDN9GjKxZwNJ2BNlgtME/auYZRleIUT+rFYrDz30EAsXLsQwDDp37lws9z2fksGEL3fxx/FEvNxdmHlfK/o3l4Q9UXY4POgbhjEfaAKsUkq9XsB5s4EflVIr7LlvdDSkp0OHDmDYluGVoC+EyCUmJoauXbsSGxtLlSpV+Pnnn2nVqtUN3/fw6UuMWbCd2MTL1PD35NNR7WgeIvP3omxxaCKfYRiDAVelVCegnmEYN+dzXjegpr0BH+DHH6FTJ3jlZQsoCxgu4OKcAxlCiOu3evVqYmNj6du3L2fOnCmWgP/LoTMMnr2F2MTLtAipzPcTu0rAF2WSo7P3bwW+yfp8LdA19wmGYbgDnwDHDcMo0sbUzZuDr2eO+XyZQxNCAGazmXfeeQeA8ePHs2fPHtasWYOb2411DJRSfLrxGGM+305Khpk7WtQianwnavjLwmCibHJ0V9gXOJn1eSLQJo9zRgF/AtOAJwzDqKOU+iDnCYZhjAfGA9SpUweAF16A8ePBkpIOnyEL8wghAIiOjqZnz55cuHCBGjVqMGLECFq0aHHD9zWZrbzy/X4W/RELwKReN/NU75slYU+UaY7u6acA3lmf++Xz/NbAPKVUAvAl0CP3CUqpeUqpCKVURFBQ0JXjVatC9UDZYU8Iob3++uu0adOGCxcuMGrUKIYNG1Ys972QamLk/G0s+iMWTzcXPhjamqf7NJSAL8o8R/f0d6KH9H8HWgKH8jjnCFAv6/MI4ESRnmBL4pNyPSEqtK5du7J582a8vLyIiorirrvuKpb7HjlziTELdnDifBrVK3nyyagIWoYGFMu9hShpNxz0DcNwAboopTbacfp3wEbDMIKB24EHDMN4XSn1Uo5z5gP/MwzjAcAduNeedowcCevXw5I5JjqDDO8LUcGFhYWRlJTEb7/9RmBgYLHc87fDZ5kYuYtLGWaa1fbnk1ER1KrsXfiFQpQRhQZ9wzA8gGeAtwAvpdTlrONewP3oxLw1gE9h91JKJRuGcSvQB5iWNYS/J9c5l4AhRfsx4IcfIDERsMgOe0JUVI8//jhubm68//77REZGFtt9lVIs2HKc11b+iVXB7c1q8s59LfHxkAohUb7Y8y/WBXgOSAVqAS9kHf8SaA4sBjLtfaBS6gLZGfzFJi4ONm+GprUy9NsIV+npC1FRJCQk0LVrV44ePUpQUBDvvvsuLi7Fk7KUabEy5fsDRG7TW+s+0bMBT/duiIuLzN+L8seeoG9CB/wfgB2GYWwFbkaX37VVSqUZhmEpuSbax9sbevcGjsu6+0JUJIsWLWL06NFkZmbSrVs31q5dW2wB/2Kaiccid7Hl6Hk83FyYfm8LBraqXSz3FqI0FPqboZSyAplKqSPA00AMuqc+CBhoGMaNbUNV3CwS9IWoKH799VeGDRuGxWLh3XffZcOGDXh5Fc/U3tGzKQyavYUtR89Tzc+TqPEdJeCLcq+ob4cTlFLRQDVgFjAdCC32VhWR2Qz33gsPPkj2DnuSvS+E00pP11U6t956K0OHDuXPP//kqaeeKrb7b/z7LIM+2sw/51IJr+XP8oldaF2nSrHdX4jSYnfQNwyjPbDUMIzb0KV0x4DTSqntQKlObl2+DEuX6lf2troypy+EM3rvvfeoVKkSixYtAuCrr76iUaNGxXb/L7Ye58HPtpOcbqZvkxosebQTtQMkQ184hwLn9A3D6Eh24t5udM/+O2A4OsM+yTCMmYB31kfQbyS8lFKPlkyTr+XpCd98AxYLYJHFeYRwRunp6fTt25eNGzfi7u6Oq2vx7k1vtlh5beWfLNyqlwZ57Nb6PNu3kSTsCadSWCJfPfTSue7AMmAKMAldS6+AZKA+OtDXzbrGFXBoxPXwgCG2Ir9dsjiPEM5m69at3HbbbSQnJ9OgQQM2btxIzZrFl06UlJbJxEW72Pj3OTxcXXjrnuYMbhNSbPcXoqwoMOgrpb4CvjIMIw4d4N9GB/tewHJ0bf4Y4G+l1KASbqt9zJLIJ4SzefHFF0lOTmbChAnMnj27WO/9z7lUxizYzrGzqVT19WDeqLa0DSuexXyEKGvsXVnCpJQaZhjGEqAykI5eKW8LEIZ+I1Bq4uP11rohIdDP3za8L0FfiPIsMTGRTZs2cdddd7Fq1Sp27dpF167XbMx5Q7YcOceEyF0kXc6kcc1KfDo6gpAqha4zJkS5VdTs/TlAOHAePfQfoZTaWeytKqKDB2HsWHj7bXKsvS+JfEKUV99//z21a9dm0KBBJCYm4uPjU+wBP3LbCUb97w+SLmfSO7w6SyZ0loAvnJ49y/AagKdhGIHA1+hFeXzRJXsjSrR1dqpZEx5+GBo1AsySyCdEeWW1Whk1ahSRkZEYhsFrr71WbOvm25gtVl5fdZDPtxwH4JFb6vGvfo1xlYQ9UQHYM7zviZ67vw1YpJTaD2AYxihgoWEYnYFS7VY3bQrz52d9sS6rpy8le0KUK4mJibRs2ZK4uDgCAwP55ZdfimXf+5yS0zOZ+NVuNhw+i7urwZuDmjMkotSXGhHCYewJ+mZgIrqXv9x2UCn1o2EY7wFW9BuDssFWsifZ+0KUK/7+/pjNZm677TZWrFiBm1vxbmZz4nwqYxbs4MiZFAJ9PZg7si3tbpKEPVGx2LMMr1kpFamUsiqlUnN9bypwHGhbQu2zS3KyTuZLS0Oy94UoR8xmMwMGDGDr1q24ublx8uRJfvzxx2IP+L8fO8/AjzZz5EwKDWv4sfzxLhLwRYV0w7tSKG1vcTTmer38MtSuDS++iAR9IcqJ6OhoqlevzqpVq3jppZcAim2jnJyitscw4tNtXEzLpEejIJZO6ExooCTsiYrJrt8wwzA8DcP41jAMz6yvqxmGUd0wDF/DMCyGYfjmOHehYRhdSqrBealXT++yl5pK9oY7MrwvRJn12muv0aZNGy5cuMCoUaNYt25dsT/DYlX8d+Wf/HvpPsxWxdiudfl0dDsqebkX+7OEKC8KW4bXUEop9Lz9wKyPAP9Db7TTAb3ufkbW+f7AA8CKkmpwXp58Ur8AiJKevhBl2ZNPPskHH3yAl5cXUVFR3HXXXcX+jEvpmTy5aDe/HDqLm4vBG4OacX+7OsX+HCHKm8ImzpYbhvGpUup7wzBQSmUahjEOncl/m1LKlPW+wJx1/ijgAnp9/tIhw/tClElWqxUXFxeef/559uzZw7Jly4q9HA8g5nwaYxdu5/DpFKr4uPPxiLZ0rFe12J8jRHmU7/C+YRgu6E12FmWV52EYRijwDvAvpdTPuc73Ap4CXlFKZZZckwtxZXhfSvaEKCsmTJhAQEAAiYmJBAcH89tvv5VIwP/jn0Tunr2Zw6dTaFDdj+8e7yIBX4gc8g36Wdn6r6B30xuZdXgWsE0p9V4el0wFTgHzir2VhXjqKWjdGtavRxbnEaIMSUhIoEGDBsyZMwfDMDh16lSJPWvxjliGf/o7iakmujcM4tvHOhNW1bfwC4WoQAqti1FK/QD8YBiGFfg3kAJXzfcbhmG8A9wNdFRKWfO/W8k4dAiioyE9nexleGV4X4hStWjRIkaPHk1mZibdu3dnzZo1eHkV/5txi1UxbfVfzN1wDICHutzE5P7huLkWfyWAEOVdYYl8q4G0rC8V8BbgkpXFf9EwjPZZ37sT6KSUOl1iLS3AnDlw/jzUrw98ZVucR4b3hSgtVquV8ePHY7FYeO+995g0aVKJPCclw8xTX+/mp4NncHMxeHVgU4Z3CCuRZwnhDArr6e8iKzMf3ZMPB6LQy+7Go3fZex8IAV42DGNSacznh4XpF5AjkU+G94VwtEOHDuHl5UVYWBirVq2iRo0aNGrUqESeFZuYxriFO/gr4RKVvd35eEQbOtevViLPEsJZFBj0lVIvAhiG4Qe8AvgDfkqpZ23nZC3F2wqIBD4BHiypxtrlStCXnr4QjjRz5kyee+456tSpwz///EP37t1L7Fk7jifyyBc7OZ9qol6QL/NHt6NuNZm/F6Iw9uyyNxXogR7e7wZsNgzjuFLqQ9s5SqnDhmEMBHYbhnGXUur7EmtxHl59Vc/n//vfEGCRnr4QjpSenk6fPn3YtGkTHh4evPXWWyX6vKU743jh232YLFa63VyND4e1obK3LLgjhD0Km9P/P2AsMADYopQ6ZhjGcHT9/g9KqWPoxXlQSsUbhvEWekTAoUF/yhT98amnyE7kkzl9IUrctm3b6NOnD5cuXeLmm29m06ZNVK9evUSeZbUqpq89xMe/HgVgdKcw/jOgiSTsCVEEhf227EcH/D9A1+5n1eevBGbkcf4CoJlhGM2KtZWF+PhjGDIE/P3JUbIn2ftClDRXV1cuX77MxIkTOXz4cIkF/NQMM49+uZOPfz2Kq4vBfwc25dWBzSTgC1FEhc3prwW99j66R+8PXERn8e80DKOR7ftKqQylVKJhGLuBQeg3DA7x6KP6hVKy9r4QJSwxMZFx48YRFRVFREQESUlJ+PiU3AY2Jy9eZuyCHRw8lYy/lxuzh7el682SsCfE9bD3bbJCZ+lbAZRSe4COwAngN7KG+LMsAtYXYxvtZzWDsoLhCq7FuzWnEAKWL19OcHAw3377Le+//z5AiQb8XTEXGPjhZg6eSqZuNV+WPd5FAr4QN8CuyKiUMgFP5zq2I+vTHrmOv188TbOPUrBuHXh5Qbf2su6+ECXBarUyatQoIiMjMQyD119/nWeeeaZEn7k8+iTPLdmLyWylS4OqfDSsDQE+kqsjxI0o991hiwX69oWqVeFcjMznC1ES2rZtS3R0NIGBgfzyyy+0aNGixJ5ltSpmrjvMh78cAWB4hzpMuasp7jJ/L8QNs6dkzw2opZSKtePc+sBbSqkhxdE4e/XuDZUqkSNzX4K+EMVp/PjxfP/996xYsQI3t5LrK6SZzPxf1B5WH0jAxYBX7mzKqE5hGIZR+MVCiELZ89vbAtgEXJm4MwyjJvAD0FkplZ7jXD/0trsO4+amh/cBSJSFeYQoDiaTiQEDBpCcnMzvv//OhAkTmDBhQok+81SSTtg7EJ9MJS83PhrWhu4Ng0r0mUJUNPYE/XQg99K6mUBLwJTruCmPcx3HIjvsCXGjdu3aRe/evblw4QJ16tTBbDaXaO8eIDr2IuMW7uDspQzCqvowf3QEDapXKtFnClER2TNJZsl65WQGvf1uruMO32EPYO/erE9keF+IG/Lqq68SERHBhQsXGD16NP/880+JB/zv98Rz/9ytnL2UQcd6gXz3WBcJ+EKUkHKfyHf5MrRpAwEBcG63racvw/tCFNWBAweYMmUKXl5eLF68mAEDBpTo86xWxXvr/2bW+r8BGNo+lFfvaoaHmyTsCVFSyv1vl1I6g79SJbIX5pHhfSHstn+/XkeradOmzJo1i1OnTpV4wL9ssvDEot3MWv83Lgb8Z0AT3hzUXAK+ECXM3p5+ZcMwjuX42gUwch0DcPiuFz4+YDJBZiYQL+vuC1EUEyZMYM6cOUycOJEPPviAJ554osSfmZCUzriFO9h3Mgk/Tzc+GNaaHo1KZvleIcTV7A366cCrdpwXDDx3/c25Pu7u+pW97r709IUoSHx8PN26dePYsWP4+/szYsQIhzx3b5xO2DudnEFooDfzR7ejYQ2ZvxfCUewN+hlKqQWFnZS1Fr/Dg/4VtkQ+mdMXIl+RkZE89NBDZGZmcuutt/Ljjz/i5VXyb5RX7T3FM4ujSc+00v6mQOaMbEugr/yuCuFI5X4CLTUV7r4bpk0ju2RPsveFyNfOnTuxWq3MmjWLX375pcQDvlKKWev/5vGvdpGeaWVI2xC+HNtBAr4QpaDI2fuGYYwFunFtGR9A5RtuURGZTLB8edbwfi9Ze1+IvBw8eJCvvvqK//73v8ycOZPnn3++xLbBzSk9Uwc/uQAAIABJREFU08JzS/ayYk88hgEv3h7O2G51ZYU9IUqJPUHf4OoRAR8gkKxa/Vz8iqNRReHnB99+C7VqAWYJ+kLkNnPmTJ577jmsVitjx44lLCzMIQH/TLJO2NsTl4SvhyuzhramV3iNEn+uECJ/9gR9r6wXAEqpWcCsvE40DCMc2FI8TbOPuzsMGpT1xZasoC/D+0KQnp5O79692bx5Mx4eHixcuJCwsDCHPHv/ySTGLdzBqaR0Qqp48+noCBrX9HfIs4UQ+Ss06CuloskR9AvhAXjfUItuhPT0hQAgLS2NWrVqkZyczM0338ymTZsc0rsHWL3/FE9H7eFypoWIsCrMGdmWan7yOylEWVAsiXyGYbQwDMMV2Ac4dPwuJQXefht270aCvhBZfHx8aN++PRMnTuTw4cMOCfhKKT765QiPfrmLy5kWBrepTeS4DhLwhShD7NlatwOwPY919m3fdwV2A7WB80AtIKk4G1mQxER4/nlISIDW/W3D+5IVLCqexMREunfvztixY3nqqadYd2X7yZKXnmnh+aV7+S5aJ+z9+7bGPNK9niTsCVHG2NPTX0QBw/tKKQs62S8DGAH8lPVGwCH8/WHwYGjVClmcR1RYy5cvJzg4mAMHDrBmzRqHPvvspQyGfvI730XH4+PhytwRbXn0lvoS8IUog+xJ5DMBGYZhTMn6Oq8ev0KX8D0FLMl6I+AQAQGwdGnWFytkcR5RsVitVkaNGkVkZCSGYfD6668zefJkhz3/z/hkxi7YTnxSOrUDvPlkVARNgiVhT4iyyp6gbwvyk4C9QFfgd6Aj8DfZ9frNgfpAz2Juo/1kcR5Rwbz00ktERkYSGBjIL7/8QosWLRz27LUHEngqKpo0k4U2dQKYOzKCoEryuydEWVaUxXkU0Be4DAwGTgEz0fP3i4C7gSil1PnibmRBzGaIi4PAQPAxyy57omKIj48nODiY1157jdTUVN55550S3/feRinFnN+OMW3NXygFg1rXZurg5ni5O2xWTwhxna4ne19lvXIfmwO8c8MtKqK4OAgNhagoZO194fRMJhN9+vQhJCSErVu34ubmxvvvv++wgJ9htvDM4j28vVoH/Of6NWLmfS0l4AtRTuT7P4VhGC7AJ+jV97oDOX+r88rQOauUSi7e5hXO1RVq19Zz+6TJ8L5wXrt27aJXr15cvHiRsLAwateu7dDnn0vJ4NEvdrLjxAW83V159/6W3NaslkPbIIS4MQX19N3RW+X6AT9QCkvs2iM0VPf2Bw0iR09fgr5wLlOmTCEiIoKLFy/y0EMPcezYMerUqeOw5/+VkMzADzez48QFalX2YvGjnSTgC1EO5dvTV0plALcbhvEnOknvbCH3amwYRphSanFxNrBIrpTsSdAXzmXhwoV4enqydOlS+vfv79Bnrz94micX7SbVZKFlaACfjGxLdX/JmxGiPLJ3IlDl8zGnPsCDgEODfkaG3mnPwwOwyIp8wnmsW7cOs9nM7bffzpYtW/Dy8iIgIMBhz1dK8cnGY0z9Uc/f39kymOn3tpD5eyHKMXuDvpH12pb18aes45PJLun7BBhvGMbtSqkfi7WVBTh5Epo1g7lzoYdZNtwRzuHRRx9l7ty5BAQEcOHCBWrWrOnQ55vMViYv28finXEAPNOnIRN7NpAFd4Qo54rS03896/PPc33PQGftpwPvAuOAfIO+YRjz4f/bu/P4mO71geOfb5ZJRMiChFhCUZQSEfsW1C16tfa9xVVRbbV00VYpddtqKb+2rmqp0qKql4uqKqqorSr2fakEjUY2QSLJZDLf3x+TRGxNkMzkJM/79cqrM3POnHnmdMwz3+U8Xx4C1mit3/mb/fyBn7TWDf8usPR0OHUKnJyQ2vvC8C5cuEDr1q05c+YMXl5e/PTTT3aPIT4pjZGL9vJ7ZALurk7M6BNEl4dl/F6IoiAvSd8EuGutb3s5nrL99J+ObXb/18BEpZSr1jr9Nvv2AJy11s2VUl8qpWpqrU/d4XU/JA8r9lWtCosWQfXqwF4Z0xfG9euvv/LII4+Qnp5OaGgo69atw2Sy7+WnJy9eZdhXuzmfkIJ/aTe+eKoxD1fysmsMQoiCk5fr9Gdxvere7bhja+27aa0TgPa3S/iZQoHvMm+vx1bd7xZKqfZAMhCdW3BubtCgAXh6cn32vnTvCwMKCgrC19eXTz75hE2bNtk94W86EUOPT3dwPiGF+pW8+P75VpLwhShicm3pa63/L5ftKUqpasDFzPv7/mb3kkBU5u0EIPjmHZRSJmAC0B1YebuDKKXCgDDgxsuWsmfvS3EeYQzHjh2jR48erFu3jipVqhAdnevv3HyntWbetgje+/EYVg2P1a/Ah70aUMIkE/aEKGrupSLfLbTWZ7XWt5vRf7MkrnfZe97h9V8HPtVaJ/7N683RWofY/soxfrxtad3rs/flciJR+E2fPp169epx/PhxFi5c6JAYzBYr41Yc4p01toT/Yoea/Kd/Q0n4QhRR9qnded0eri/Y0wA4cZt9HgHaK6WeA4KUUl9orZ++0wFjY+Hdd6F/P0156d4XBpCamkqHDh3YsWMHJpOJhQsX0qdPH7vHcSnZzDOL9rArIgE3Fyc+7N2Arg0C7B6HEMJ+7J30VwJblVIBQGegn1LqHa31+KwdtNZtsm4rpTb/XcIH8POD4cPBr2zmNAInl8yp/EIUTi1btmTv3r3UrFmTbdu24efnZ/cYTsdcZdhX4ZyNv4ZfKTfmPhVCg8r2qwEghHAMuyZ9rfUVpVQotkI+U7XW0cCBv9k/NLdjlisH48djq9ID0rUvCq2kpCQ8PT35/PPPWbhwIR9//LFD4thyMpbnF+/lapqFehVLM/epECp45XqhjBCiCLB3Sx+t9SWuz+DPP9mFeWQSnyhc4uLiaN26NTExMVy8eJGQkBBCQkLsHofWmq92RDL5h6NYNXSuV57pfRrgYbL714AQwkEM3w+elATbt0N6qhTmEYXPihUrqFSpEsePH6dmzZpYLBaHxJGeYWX8ysNMWm1L+KPa12DWgGBJ+EIUM4ZP+qdPQ6tWkJQoK+yJwsNqtTJgwAB69OhBeno6U6ZM4bfffsPd3f7DT4nXzAz+8ncW7zqHycWJj/sF8fI/auHkJCV1hShuDP8zv2RJW+19k1PmNfoyc18UAtHR0Xz33XeUKVOGzZs3U69ePYfE8UdsEk9/FU5EXDJlPd2Y+1QjGlbxcUgsQgjHM3xLv2ZNW/d+STfp3heOt2jRIpKSkggICGD79u1ER0c7LOFvPRVL91nbiYhLpk6F0qx6vqUkfCGKOcMn/Wyy2I5wILPZTMeOHXnyySfp3r07AE2bNsXFxTGdaQt3RjJk/m6upFr4x0P+LHumORW9ZYa+EMWd4bv3s2XIsrrCMfbu3UuHDh1ITEwkMDCQ+fPnOywWS4aVyT8c5eudZwF4NrQ6r8j4vRAik+Fb+vv22a7Vv153X5K+sJ/p06cTEhJCYmIiQ4cO5cyZM1SqVMkhsVy+ls6Q+bv5eudZTM5OzOjTgLGdakvCF0JkM3xL32qF5GSur7AnSV/YUdWqVSlZsiRLly6lS5cuDosjIi6ZYV/t5kxsMmVKmpjzVCMaBfo6LB4hROFk+JZ+w4Zw4QI5uvelOI8oWOvWrePRRx8FoGfPnly+fNmhCX/H6Ti6zdrOmdhkapcvxarnW0rCF0LcluGTvpMTeHuTo3tfyvCKghMWFkanTp3YsGEDe/fuBcDJgWs9LN51lqe+/J3LKek8UsePZSNbUMnHw2HxCCEKN8N372fL7t6Xlr7IfxcuXKBVq1ZERETg5eXFhg0bCA4Odlg8lgwr76w5xoIdkQCMaPsAYx+tjbOM3wsh/obhk/6ZM/DCC/DJQCnOIwqG1WqlZs2aXLt2jdDQUNatW4fJ5Lgfl1dS03n+m338ejIWV2fFe90fpndIZYfFI4QwDsMn/UuXYPVq+KSvXKcv8pfFYsHJyQknJydGjx5N+fLlGTVqlENjOhufzLCvwjkdk4RvSROfP9mIxlVl/F4IkTeGT/rVqsH//R9SnEfkqyNHjtCuXTvatGnDsmXLePfddx0dEr+dieeZRXtIvJbOg/6ezBvcmMq+Mn4vhMg7w0/k8/WFJ55AivOIfDNt2jTq169PbGwsbm6F4/O0dPc5Bn2xi8Rr6bSrVY7lI1tIwhdC3DXDt/SzyXX64j5du3aNRx55hJ07d2IymVi8eDG9evVyaEwZVs17Px5j3rYIAJ5uVY03utSRCXtCiHti+KSfkABr1sBjSiryifuzaNEidu7cSa1atfj111/x8/NzaDxXU9N5Yck+Np2IxcVJ8W73evRtXMWhMQkhjM3w3fsRETB2LNe79yXpi7v0ww8/ALZr8JctW8bx48cdnvDPxV+j5+wdbDoRi4+HK4uebioJXwhx3wyf9H19oUsXrk/kkzF9kUdxcXHUqVOHrl27Mm/ePMBWYc/Rfo9IoNun2zl5MYkafp6sfK4lzR4o4+iwhBBFgOGTfrVqMG0aMntf3JUVK1ZQqVIljh8/TtOmTenfv7+jQwLgu/DzDPziNxKSzbR5sBz/e7YFgWVKOjosIUQRYfikny1DxvRF3gwePJgePXqQnp7OlClT+O233/DwcOxM+KwJe2OXHSQ9QzO0ZVW+HBxCaXdXh8YlhChaDD+RLyMDrl0Dj6zZ+9K9L3KRkJBAmTJl2Lx5M/Xq1XN0OCSlWRj97T5+PhaDi5Pi7SfqMrBpoKPDEkIUQYZP+vv3Q9u2sPu5rO59qb0vbjV79mzi4+MZP348K1asAMDFxfEf//MJ1xj+dTjHo6/iVcKV2YOCaVG9rKPDEkIUUY7/1rtPTk7g4UGO7n1ZZU9cZzab6dKlCxs3bsTDw4Nx48YVimQPEB6ZwIiFe4hPNvNAuZLMG9yYamVl/F4IUXAMP6bfsCFs2cL14jzO0tIXNuHh4fj7+7Nx40YCAwM5ceKEQ5fBzWn5nj8ZMHcX8clmWtcsy4pnW0rCF0IUuMLR5MkPFpnIJ64LDw+nSZMmaK0ZNmwYc+bMKRQJ32rVTFt/gtmb/wBgcPNAJvzzIVycHR+bEKLoKzpJP7s4j3TvF2dWqxUnJyeCg4Np06YNY8eOpUuXLo4OC4DkNAtjlu5n/dGLODspJnV9iCebV3V0WEKIYsTwzYsTJ2D0aHIU55Hu/eJq3bp1+Pj48MMPP+Dk5MTmzZsLTcKPSkyh12c7WX/0IqXdXfhqaBNJ+EIIuzN80k9KgkOHkOI8xZjVamX48OF06tSJq1evcuzYMUeHdIO95y7xxH+2c+yvK1QrW5IVz7WkVU2ZoS+EsD/Dd+/XqgUzZgBrJOkXRxcuXKBly5ZERkbi5eXFzz//TEhIiKPDyrZqfxSvLjuI2WKlZY0yzBoQjLeH9EYJIRzD8C19T09o0IDrY/pSnKdYGTRoEJGRkbRv356YmJhCk/CtVs2H607w4rf7MVusDGxahQVDm0jCF0I4lOGTPgBaX79OX8b0izyLxcLevXsBWLlyJV9++SUbN27EZCoc/++vmS08u3gv/9l0GicFbz9el3e61cNVZugLIRzM8N9C0dGwYlmOSXyF4LIsUXCOHDlCQEAATZs2JTo6mtKlSzN06FBHh5Xtr8sp9P5sJz8diaaUuwsLhjZhcIuqKKUcHZoQQhg/6UdFwbeLpGu/OJg2bRr169cnNjaWnj17OnzN+5vtP5/I4//ZzpELVwgs48GKZ1vQ5sFyjg5LCCGyGX4in78/dOtqhj+RSXxFVGpqKu3bt2fnzp2YTCYWL15Mr169HB3WDb4/cIFX/3uANIuVZg/4MntgI3xKFo7hBiGEyGL4pF+pEvTvlQofIUm/iHJycuLo0aPUrl2bLVu2FKoWvtWq+WjjKT7ZeAqA/k0q8/bj9TC5GL4TTQhRBBk+6QMyia+IGjt2LIMGDaJ+/fpERkbi7e3t6JBukGLO4JX/HmDNob9wUvDmYw/xr5Yyfi+EKLwMn/RTUiA6Ko3yICV4i4i4uDhat27N8ePH+eWXXwgPDy90CT/6cirDvw7nUNRlPN1cmDmgIe1qFZ4eCCGEuB3D90EePQoz/y9zhT0Xaekb3fLly6lUqRLHjx+nWbNm/Prrr44O6RYH/0zkiVnbOBR1mcq+Jfjfsy0k4QshDMHwSd/dHQL8s7r3ZUzfyN555x169epFeno6U6ZMYefOnXh4eDg6rBusOfgXfT7fycUraTSp6suq51rxoH8pR4clhBB5YvikX7cuPBcmJXiLgv79+1OjRg0OHDjA66+/7uhwbqC15pONp3jum72kplvp3agSi55uiq/M0BdCGIjhkz4gi+0Y2KeffkqlSpVISkqievXqnDp1inr16jk6rBukpmfwwrf7mbHhJErBm13qMLVXfZmhL4QwHMNP5AOk7r4Bmc1mOnfuzC+//IKLiwt79+6lTZs2jg7rFjFXbBP2Dvx5mZImZz7p35AOdfwdHZYQQtwTwyf9Q4dgycI0+puQlr5BhIeH07FjRxITEwkMDGTbtm1UqlTJ0WHd4nDUZYZ/Hc5fl1Op5FOCLwaHULt8aUeHJYQQ98zw/ZNmM6QmS/e+kXTo0IHExESefvppzpw5UygT/k+H/6L3Zzv563IqIYE+rHyupSR8IYThGb6lX68e9OyWBluQ4jyF2JUrVzCbzZQtW5aFCxfi6upK586dHR3WLbTWzNp0mg/XnwSgR3BFpvR4GDcXZwdHJoQQ98/wSd/NDUqXyGrpS3Gewmjt2rX07NmTSpUqcfLkSR5//HFHh3RbqekZvL78ICv3X0ApeK1TbUa0eUAq7BVDV65cISYmhvT0dEeHIooZV1dX/Pz8KF26YHoWDZ/0gRyz96WlX5hYrVbCwsKYN28eSin69evn6JDuKPZqGmELw9l3LhEPkzMf9Q3iH3XLOzos4QBXrlzh4sWLVKxYkRIlSsiPPmE3WmtSUlKIiooCKJDEb/ikf+4cHDlopi5IS78Q+fPPP2nVqhVnz57F29ubDRs2EBIS4uiwbuvohSs8/dVuLlxOpaJ3CeY+FcJDATJ+X1zFxMRQsWLFQlcYShR9Sik8PDyoWLEiFy5ckKR/O7GxEHUulbruyCV7hciZM2c4d+4cHTp04Mcff8RkKpy9MOuPRDN66X6umTMIruLN50+GUK6UfI6Ks/T0dEqUKOHoMEQxVqJEiQIbWjL87P3KlaFOTeneLwwsFgtjx47FarXSpk0bIiIi+PnnnwtlwtdaM3vzH4xYtIdr5gy6N6zIN8ObScIXANKlLxyqID9/hm/p+/lB5QpmOI907zvQkSNHCA0NJS4uDnd3dyZPnkxgYKCjw7qtNEsGb/zvEP/baxs3e/XRWjwbWl2+6IUQRZ7hW/oAWDJX2ZNL9hxi6tSp1K9fn7i4OPr168ekSZMcHdIdxSWlMXDuLv63N4oSrs58NiiY59rVkIQvirS4uDgGDBiAj48Pfn5+TJgwIXtbamoqzzzzDF5eXvj7+/Pee+9lb5s0aRJKKZycnPDz86NPnz6cOHHCEW9B5BPDt/SvXIErCWZKgxTncYAuXbqwdu1aTCYT33zzDT179nR0SHd0PPoKwxaEE5WYQgUvd+Y+FUK9il6ODkuIAte3b18yMjJYvnw5Bw4c4NVXX6VevXr07duXF154gbVr17Jo0SIuXLjACy+8QK1atbL/LVeoUIGVK1dy+vRpJk+eTIsWLdi3bx9VqlRx8LsS98LwSf/UKYj4I40GzkjSd4CssfutW7dStmxZR4dzRxuPXeSFJftINmfQoLI3c59shF9pGQ4SRV9kZCS//PILe/fupWHDhrRv356tW7fy9ddf06ZNG7788ksWLVpE165dAdi5cyczZ87MTvomk4kmTZrQpEkT2rdvz4MPPsiUKVOYPXu2I9+WuEeG794vXRq8PWXBHXsaM2YMjz32GACvv/46x44dK7QJX2vNnF//4Omvw0k2Z9C1QQBLw5pJwhfFRkJCAmDr4s8ydepUJk+ezMaNG8nIyKBjx47Z2xo2bMjRo0dve6zy5cvTtWtXfvzxx4INWhQYwyf9mjUhMEBq79tDTEwMtWvX5qOPPmLr1q2kpqY6OqS/ZbZYGbvsIO/9eByt4eWOD/JJvyDcXaWkrig+6tatS+XKlRkyZAj/+9//0FpTo0YNGjVqxPHjxylVqhRlypTJ3n/w4MFs2rTpjserX78+586dIyUlxR7hi3xm96SvlJqnlNqplBp/h+1eSqm1Sqn1SqkVSqncZ+dZJOkXtGXLllG5cmVOnDhB8+bNiY6Oxt298LaW45PSGPTFLv6750/cXZ34dGAwozrUlAl7othxc3Nj9erVuLm50bNnT0JCQti5cydga/3fXADG29ubunXr3vF4Pj4+ACQmJhZc0KLA2DXpK6V6AM5a6+bAA0qpmrfZbSAwQ2v9DyAa6JTrgTOke78gRURE0Lt3bywWC1OnTmXHjh2FulrZyYtX6fbpdn6PTMC/tBv/HdGCLg9XcHRYwuCUsv3l1LWr7bHVq68/NmeO7bGwsOuPXbhgeywg4MbnN2pke3zPnuuPTZpkeyznRTA5t9+LBg0acPz4cT799FMuXLhAaGgoa9asIT09HScnWxr47bffUEpl/92J/HA2Nnu39EOB7zJvrwda3byD1vpTrfWGzLvlgJib91FKhSmlwpVS4Xv2wIXzUpynIGSNBVarVo2xY8dy8OBBXn31VQdH9fc2HY+hx6c7OJ+QQv1KXnz/fCseriQz9IUwmUyMHDmSQ4cOUadOHUaMGEHJkiVJTk4GbN32+/btY+7cuX97nEuXLgHg5SX/rozI3km/JBCVeTsB8L/Tjkqp5oCP1vq3m7dpredorUO01iEALsgqe/nt008/xc/Pj3HjxgHwwQcf/G2Xn6Nprfli6xmGfbWbpDQLj9WvwNKw5vjLhD2RT7S2/eW0erXtscyJ74Ctha+1rcWfJSDA9tiFCzc+f88e2+ONGl1/bNIk22M5W/o5t9+tuXPn0qnT9Q7TsmXLMmHCBKKioihTpgwJCQlcvnwZDw8PgoKC8Pe/49cyAIcPH6Zq1aqFurdP3Jm9k34SkFXU2vNOr6+U8gVmAv/K7YDBwVDOJ6t7X1r698tsNtO+fXuee+45lFLUrl3b0SHlymyxMm7FId5Zcwyrhhc71OQ//RtSwiQT9oRwd3dn48aNN4zBx8fHU6JECXr06AHA6hzjEwcOHLjjsWJjY/n+++/p1q1bwQUsCpS9r9Pfg61L/zegAXBLaafMiXv/Bd7QWp/N7YBKgcow2+7IRL77snv3bjp27Mjly5epWrUqW7dupVKlSo4O629dSjbzzKI97IpIwM3FiQ97N6Brg4DcnyhEMdG1a1d8fHzo1asXr7/+OjExMUycOJGwsDAefvhhevfuzfPPPw+As7MzM2bMuOH5ZrOZ3bt388cff/DOO+9QqlSp7B5AYTz2bumvBJ5USs0A+gBHlFLv3LTPMCAYeFMptVkp1TfXo2aV4ZXu/fsyd+5cLl++zPDhw4mIiCj0Cf90jG3C3q6IBPxKufHdiOaS8IW4ibe3Nz///DNWq5UePXrwxhtv8NRTT/HBBx8AsGDBAnr37s3IkSOZNGkSzz333A3P/+uvv2jatCmjR4+mSZMm7Nq1i3LlyjnirYh8oPTNg1QF/YJK+QAdgV+11tH3ezwfnxAdM+YvXK1J8Pp5cJd10O/GlStX+PbbbwkLC8NqtbJ//36Cg4MdHVautpyM5fnFe7maZqFuQGm+GBxCBS9ZDlXcv2PHjlGnTh1HhyGKudw+h0qpPVnz2u6G3cvwaq0vcX0G/31LTAQnq0zkuxdr166lZ8+epKSk0Lp1a+rUqVPoE77Wmq92RDL5h6NYNXSuV57pfRrgYTJ8RWkhhChwhv+mfOABcCbddsfZ1bHBGITVaiUsLIx58+ahlGLChAmGaNmkZ1iZ9P0RFu86B8Co9jUY88iDODnJdcNCCJEXhk/6Pt5W2w1nt1srZ4hbmM1matWqRWRkJN7e3mzYsIGQkLvuIbK7xGtmnl28lx1/xGNycWJar/o8EVTR0WEJIYShGD7pZ184K137eWIymfD19aV69er8+OOPmEyF/zLHP2KTePqrcCLikinr6cbcpxrRsIqPo8MSQgjDMXzST0jIbOlLNb47slgsdOvWje7duzNs2DD23G9NTzvaeiqW5xbv5UqqhToVbBP2KnrLhD0hhLgXhk/6UX9mtvSl7v5tHT58mNDQUOLj44mKimLYsGGODinPFu6MZNLqo2RYNf94yJ//6xtESTfDf2SFEMJhDL+0rq9PVve+JP2bTZkyhQYNGhAfH0///v0N08K3ZFh5a9VhJqw6QoZV82xodT4b1EgSvhBC3CfDf4tWDMjq3pekn9O0adMYN24cbm5uLFmyhO7duzs6pDy5fC2d577Zy7bTcZicnXi/58P0CC7cRYKEEMIoDJ/0Iat7X8b0wTY732Qy8eKLL/Lrr78yf/58ypYt6+iw8iQiLplhX+3mTGwyZUqamPNUIxoF+jo6LCGEKDIM372fYclq6cvs/RdffBFPT08OHjyIyWRi9erVhkn4O07H0W3Wds7EJlO7fClWPd9SEr4Q92nBggUopVBK4eTkRGBgIK+88kr2croF9ZpVq1YtsOPnFBkZmf3+bv5bsGCBXWIwGsO39P84nTWmX3xb+jExMbRu3ZqTJ0/i6elJSkqKo0O6K4t3nWXiqiNYrJpH6vjxUb+GeMr4vRD5Zvfu3ZjNZn7//XcmTJjAxYsXWbhwoaPDyjefffYZjW5af7hatWoOiuZW+/fvZ/PmzYwePdrRoRg/6bu4FO/Z+8uWLWPgwIGYzWZatGjBhg0bDLPOtSXDyjtrjrFgRyQAI9o+wNhHa+MsFfaEyFdZBbhatGhBcnIykydP5osvvsDNrWh8b9aqVatQFxnbv38/H32C+5OsAAAgAElEQVT0UaFI+obv3n+gWvGeyPfSSy9hsViYOnUq27dvN0zCv5Kazr++CmfBjkhcnRXTetXnjc51JOELUcCCg4Mxm83Ex8c7OhThAIZP+tcr8hWfpP/HH3+wa9cuADZt2sThw4d59dVXHRxV3p2NT6bHpzv49WQsviVNfDO8Gb1DKjs6LCGKhYsXL6KUokyZMgBERUXRrVs3vLy8KF++PGPGjMFqtTWmssbM9+/fT69evfD09KR27drs3Lkz+3hHjx6lZcuWuLu707x5cyIiIm54vUuXLjFo0CA8PT0pX748b7/9Nlmru4aGhjJixAgaN26Mr68va9asoXnz5nh7e7Ny5cp8eb9paWmMGjUKX19ffHx8GDVqFGlpadnbN2/ejFKKjIwM/v3vf1O1atUbhj7S09N57bXX8Pf3p0yZMgwZMoQrV65kb79y5QqDBw+mXLlyeHt706NHD2JjYwGYNGkSSimGDh3K2bNns+cbTJo0KV/e2z3RWhv6r1GdalpPLK31ipG6OJg5c6Z2dnbWpUuX1hkZGY4O567t/CNON3h7nQ587QfdccZmfS4+2dEhCXGDo0ePOjqEfDN//nxt+5q3OXz4sK5Vq5Z+5JFHsh9r27atrlevnv7555/1smXLtK+vr54/f77WWuuIiAgN6Hr16unnn39eb9iwQQcHB+ugoCCttdbp6em6Zs2aunnz5vqnn37SkydP1q6urjowMDD7+P/4xz/0gw8+qFetWqU/++wz7enpqd97773s1y5VqpRevny5btCggXZxcdHz58/Xjz76qO7cuXOu7y8rvk2bNt1xn+HDh+vy5cvrb775Ri9ZskT7+/vrsLCw7O2bNm3SgA4LC9ONGzfW//d//6ePHTuWvf21117T/v7+eunSpfqHH37Q1atX13379s3ePmrUKB0QEKBXrVqlv//+e/3www/rp59+WmutdVRUlN69e7eeOHGirlChgt69e7fevXu3joqKyvW95fY5BML1PeRMw4/pR0dnLbhTtCfymc1mOnXqxKZNm3B1dWXWrFk4ORmro2bp7nO8ueIwFqumXa1yfNK/IaXcZWVEUfhVfX2No0MAIPL9x+7peSrHYmTBwcHMmzcPsDX6BgwYQMuWLalbty4Wi4VZs2axa9cuhgwZkv2cOnXqMHPmTADGjRtHv379AFi/fj2nTp1i7dq1VK9enUcffZR9+/axd+9eALZt28b69evZt28fQUFBAFy7do0JEybw0ksvAdC/f3969OjBqlWr8Pf3Z8iQIURERLBly5Y8v7927drdcD8iIoKqVaty7tw55s2bx/Lly+nWrRsAbm5u9OrVi/Hjx1O58vUexmPHjrFt27Yb1iNJSUnho48+4vPPP6dPnz4AxMXFMXz4cFJTU3F3d+fcuXM0aNCAxx9/HICaNWuSkJAAQEBAAAEBARw+fBiTyVQo5h0YK2vcRrq56HfvHzlyBD8/PzZt2kS1atWIjIxk0KBBjg4rzzKsmn//cJTXlh/CYtU83aoaXwxuLAlfCDvZt28fa9asQSnF2LFjqVKlCmD7MdCnTx/WrVvHY489hr+/P5s3b77lCqCwsLDs22XKlMFisQBw6tSp7AW8srRp0yb79v79+/Hy8spO+GDr0k9OTub06dMAVKhQITuWnLfvxty5c9m3b1/2X0BAAAAHDx7EarUSGhp6w+tbrVYOHjx4wzGmT59+ywJkp0+fJi0tjSFDhmR3zQ8ZMoT09HTOnbMt8T1s2DA2btxIixYtGDt2LFFRUbRo0eKu4rcnw7f0/f2K/kS+cuXKYbFYGD58OHPmzHF0OHflamo6LyzZx6YTsbg4Kd7tXo++jas4Oiwh7sq9trALi6CgIIKCgnj88cf54IMP6Nu3LwBXr14lODgYPz8/BgwYwIQJE5g9e/Ytz7/T5W9Wq/WWHkdnZ+cb7t+cwLPu66z5WPmgRo0aN/ywuFnOGO70+o0bN77leVn7/Pe//6VGjRo3bMv64dS1a1dOnDjBTz/9xJYtW+jcuTPPPvssH3300b29mQJm+Ja+ybVoXrKXmJjII488QkxMDH5+fiQmJhou4Z+Lv0bP2TvYdCIWHw9XFj3dVBK+EA40btw49u3bx4YNGwDYuHEjERERrF27lhdeeIFmzZplt8BzujmRZ6levTrx8fHZrV6A7du3Z98OCgoiMTHxhlb1li1b8PDwoGbNmvn1tu6ofv36ODk53TBUsGXLFpycnKhfv36uz69RowYmk4nU1NTsH04lS5bkww8/5NKlSwBMnTqV8+fP88wzz7BkyRImT57M/PnzbziOu7t7oamfYviWPrroLa37448/0rNnT1JTU3n33Xf5+OOPcXEx1v+q3yMSeGbRHhKSzdTw82Te4BACy5R0dFhCFGtNmjShQ4cOfPDBB3Ts2DF7Bv/8+fN5+OGHmTVrFjt27MhzYZtOnToRGBjIk08+yfjx49mzZw/Lly+nYsWKALRq1YqOHTvSt29fpk6dSnR0NG+99Rbjx4+3S42AKlWqMGzYMJ555hlSUlLQWvPSSy/x9NNPZ7fU/46Hhwdjxozh1VdfRWtNxYoVmTRpEpcuXaJ8+fIAHD9+nCVLlvDuu+9SokQJvv/++1sqEgYHBxMXF8ecOXOoW7cu27Zt47XXXiuIt5wrY2WS20hOyhrTN34ZXqvVyrBhw7JLZ06cONGxl3bco+/Cz/PmikOkZ2jaPFiO/wxoSGkZvxeiUHjzzTdp37494eHhtG7dmjfffJP33nsPFxcXOnfuzIgRI9i4cSMZGRm5HstkMrF27VpGjhxJt27dqF27Ni+//DLffvtt9j5Lly7l+eefp3///pQsWZIxY8bYNeHNnDkTNzc3nnnmGQAGDRrEhx9+mOfn//vf/8ZqtfLyyy+TmppK+/btWbRoUfYwwfTp0xkzZgxDhw4lKSmJkJAQFi1adMMxHnzwQT777DMmT55MdHQ0tWvXdljSV/k5ruIIVbzK63NjUqDzNGgalvsTCrEOHTrwyy+/4O3tzcaNGwkODnZ0SHclw6r54KfjzPn1DABDW1blzS51cHE2/CiSKEaOHTtGnTp1HB2GKOZy+xwqpfZore/6cgDDt/Q9Sxq/ez9rMsyECRMwmUysWrXqllmkhV1SmoXR3+7j52MxuDgp3n6iLgObBjo6LCGEEDkYPul7lDBu977FYuGJJ57gwIEDnDt3jtDQ0BsuLTGK8wnXGP51OMejr+JVwpXZg4JpUd0Yq/sJIURxYvikD8YsznP48GFCQ0OJj48nICCAxMREfH2Nt5RseGQCIxbuIT7ZzAPlSjJvcGOqlZUJe0IIURgZfrA1w2K84jxTpkyhQYMGxMfHM2DAAM6fP2/IhL98z58MmLuL+GQzrWuWZcWzLSXhCyFEIWb4ln5ykrGK88TFxTF+/HhcXV1ZsmQJ3bt3d3RId81q1Uxbf4LZm/8AYHDzQCb88yGZsCeEEIWc4ZO+i7MxivPs2rWLhg0bUrZsWb777jvatm1L2bLGG/dOTrMweul+Nhy9iLOTYlLXh3iyeVVHhyWEECIPDN808/Ao/N37L774Is2aNeOf//wnAD179jRkwo9KTKHXZzvZcPQipd1d+GpoE0n4QghhIIZv6dsq8jkXyqQfExND69atOXnyJJ6enrz11luODume7T13ibCv9xCXlEa1siX5YnAI1ct5OjosIYQQd8HwLX104ezeX758OZUrV+bkyZO0aNGCixcv0qpVK0eHdU9W7Y+i35zfiEtKo2WNMqx4toUkfCGEMCDDJ31zWuHs3r9y5QoZGRl8+OGHbN++HQ8PD0eHdNesVs2H607w4rf7MVusDGxahQVDm+DtYazLI4UorrJKeiul8PX1pUuXLvz+++8F8lqhoaH3VTb8fp9/L3Ken5v/IiMj7RqLvRi+e1+pwjN7/9SpU7z33nvMnz+foUOH0rt3bzw9jdkivma28NLSA/x0JBonBRO71uWp5oF3vc61EMLxfv/9d86fP8+0adNo27YtW7duJSTkriu4/q3PP/+cUqVKOez596Jr167s3r0bgMcff5x//vOfhIXZyrkHBATYNRZ7MXzSd3UpHN37M2fOZMyYMWRkZDBs2DBatWpl2IT/1+UUnv4qnCMXrlDK3YX/DAim7YPlHB2WEOIeNW7cmMaNG9OpUyceeughJkyYwNq1a/P1NWrVquXQ59+LMmXKZK80aDKZCAgIyPcfQ4WN4ZP+9aV1HZP0U1NT6dSpE1u2bMHV1ZWvvvrKsGP3APvPJzL863Bir6YRWMaDeYNDqOFn31/fQoiC4eHhwcCBA5k2bRpms9lwa3yI+2f4Mf3siXwOSPpWq5UqVaqwZcsWHnjgASIjIxk4cKDd48gvq/ZH0ffzncReTaPZA76sfLalJHwhipj69euTnp7OmTO21TCvXr3K8OHD8fHxoXz58rz00kuYzebs/ePi4hgwYAClSpWiQoUKjBo1imvXrt1y3DuNyUdFRdGtWzd8fHwoW7Ys//rXv0hNTc3z8y9dusSgQYPw9PSkfPnyvP3222StDhsZGYlSiv3799OrVy88PT2pXbs2O3fuvMezc6sFCxZQtWpVUlJSGDNmDAEBAWzZsiV7e27nL7ft9mb8lj4ajUI52f+tODk50bNnT7TWfPbZZ3Z//fxiybAydd2J7CVx+zepzNuP18PkYvzfhEKIG/n4+AC2ZAowfPhw9u3bx8KFC0lJSeHZZ5/FZDLx/vvvA7a6IjExMSxevBiLxcILL7yA1Wpl1qxZeXq9kSNHcubMGb777jsuX77M6NGjmT59Om+++Waent+vXz8iIyP55ptv+Ouvv3jllVcwmUy88cYb2fs8+eSThIaGsnLlSl577TWeffZZ9u3bdzenJVc9evTAYrHwxhtvUKNGjezHczt/uW23tyKQ9CFDueNipwlmiYmJtGnThpCQEL788ktmz55tl9ctKAnJZkYt2cv20/G4OCkm/PMhmbAnxM0meTk6AptJl+/7EDn/bZ85c4alS5eyefNm2rZtC8DRo0f54osveP/999m8eTO//vorhw4dol69egCkpaWxbdu2PL/euXPnaNOmDR07dgSgevXqef5+2bZtG+vXr2ffvn0EBQUBcO3aNSZMmMBLL72UvV+dOnWYOXMmAOPGjaNfv355ji8vzp49S7NmzViyZMldnb/ctjtCkUj6ysU+41I//PADvXv3JjU11e6zTAvC4ajLjFi4h6jEFMp6mpg1IJimD5RxdFhCiAKU1cL39vbmyJEjALdd0ttsNnPo0CG8vb2zEz5A//796d+/f55fb8SIEYwaNYpTp05lVyZt2rRpnp67f/9+vLy8shN+VqzJycmcPn2akiVtC3xlzbgH2+Q8i8WS5/jywmQyMX369Ft+rOR2/nLb7og5FUUi6TubCnY832q1MmzYsOxrOidNmsTEiRML9DUL2sp9Uby2/CBpFisNKnnx2ZONqOBVwtFhCVE45UMLu7A4fPgwJpOJGjVqcOrUKYDb1hJxcbl9ekhMTOTw4cM0adIkT0lr5MiRtG3blvXr1/PLL7/w7rvvMmPGDEaPHp2neG9OtFn3s8b1AapVq5anY92rChUqULFixVsez4rhTucvt+2OUDQGbV3cC/TwCxcuZMGCBXh7exMeHm7ohG/JsDJ59VFGL91PmsVK70aVWDqiuSR8IYqB1NRUFi9eTJcuXXB1daVu3bqArWETFBREUFAQKSkpzJgxA4vFQr169UhMTMxusQKsWLGCDh065LmL/vXXX0drzejRo/n+++8JCwvjyy+/zNNzg4KCSExM5ODBg9mPbdmyBQ8PD2rWrJn9mLOzc56Ol99yO3+5bXeEItHST8eEawEc99ixY9SpU4fBgwfz559/8uqrrxr6Epf4pDSe+2Yvv51JwMVJMfHxugxqWkXG74Uo4sLDw4mKimLatGnEx8czZcoUwDa+3rdvX4YNG8aUKVMoUaIEr7zyClWrVsVkMtGuXTvatGlDnz59eP/99zGbzUyaNImnnnoKV9e8fev+/vvvhIeH8/rrr2OxWNi8eXOer8lv1aoVHTt2pG/fvkydOpXo6Gjeeustxo8fj5ub4wuy5Xb+ctvuEFprQ/81quCkE95trvNTenq67ty5swb0ggUL8vXYjnLwfKJu/t7POvC1H3Sjf2/Qv0fEOzokIQqlo0ePOjqEfDN//nwNaED7+PjoXr166ePHj9+wz5UrV/SwYcO0t7e39vHx0U899ZSOj7/+/RAbG6v79++vPT09dUBAgB49erROTk6+5bXatm2rJ06ceMvjZ8+e1d27d9e+vr7a09NTP/bYY/rcuXN5fn5CQoIeMGCALlmypPbz89MTJ07UGRkZWmutIyIiNKAjIiKy99+0aZO2pba7ExgYeNvXnz9/vg4MDLzj83I7f7ltv5PcPodAuL6HnKl0jnERIwoJcNYbX2qD1yub8uV4hw8fJjQ0lPj4eCpWrMjWrVsLfLyooC3f8ydvrDiE2WKlYRVvZg9sRHmvgh0SEcKosnr4hHCk3D6HSqk9Wuu7Lh9YJMb0vXzzp5tnypQpNGjQgPj4eAYMGMC5c+cMnfDTM6xM+v4IL//3AGaLlf5NKvNtWDNJ+EIIUUwViTH9/KrGt379elxdXVm6dClPPPFEvhzTUeKS0nh28V5+j0jA1Vnx9uP1GNC0iqPDEkII4UBFI+nfx2I7mzdv5tixY4wcOZJ169aRlJSEr69vPgZnfwfOJ/LMoj38dTkVv1JuzB7UiEaBPo4OSwghhIMVie79c3/d2yzIUaNG0a5dO0aPHp1dKMHoCf+/4efp/flO/rqcSqNAH34Y1UoSvhBCCKCItPSt6u7GqGNiYmjVqhWnTp2iVKlSrF271tCX4gGYLVbeWXOUr3eeBWBQsyq89c+6Uj9fiHugtZZLWYXDFOQE+yKR9AOr5717/9ixYwQFBWE2m2nVqhUbNmzA3d3YE9tirqby3OK97I68hMnZiX93q0vfxjJ+L8S9cHFxwWKx5Pk6dCHym8ViKbCKfUWiGXg3tfdr1apFjRo1mD59Olu3bjV8wt937hJdZ25jd+Qlypd2Z+mIZpLwhbgP7u7uJCUlOToMUYxdvXq1wHJTkUj6uZXhPXXqFFWrVmXz5s04OTlx5MiRG1ZoMqqlu8/R9/PfuHgljcZVffh+VEsaVpHxeyHuR7ly5YiNjeXatWsF2s0qxM201ly7do24uDjKlStXIK9RJLr3z/9lovIdtn388ce89NJLWK1WVqxYcdvVjozGbLHy9uojLN51DoCnmgcy/rGHZPxeiHzg7u6Ov78/0dHRpKWlOTocUcy4ubnh7+9fYC39IpH0Lye73ZL0U1NT6dSpE1u2bMHV1ZWvv/6agQMHOiS+/BRzJZWRi/ey5+wlTC5OvNOtHn1C7vSTRwhxL7y8vPDy8nJ0GELkuyKR9CtXvXUiX48ePdiyZQsPPPAAW7duJSAgwAGR5a+df8Tzwrf7iL2aRgUvdz4b1IgGlb0dHZYQQgiDKBL9wTnL8EZHRwOwYMECXnnlFf744w/DJ3yrVTNr02kGfvEbsVfTaFrNl++fbyUJXwghxF0pEi19XNxITEykTZs2nDhxgvPnz+Pn58e0adMcHdl9S0g2M2bpfracjAXg+XY1GP1ITVyci8TvNSGEEHZk96SvlJoHPASs0Vq/c6/75PT9puP0bVuB1NRUgoODDX8ZHkCGVbN87598uO4EMVfT8PFwZUbfINrV8nN0aEIIIQzKrklfKdUDcNZaN1dKfamUqqm1PnW3++QUd03Tc9wMMrRi4MiXGTjyZbafTQaSC/jdFAxzhpVjf11lw9Fo/oi1vYeQQB8+6d+QAO8SDo5OCCGEkdm7pR8KfJd5ez3QCrg5oedln2yx1zRlSpdAPTGFbaVrsG3x3nwN2JEqepfg1Udr8XiDAJycpCSoEEKI+2PvpF8SiMq8nQAE38s+SqkwICzzbtq1xJTDfDU6n0N1vLNA9zccHUW2skCco4Mo4uQcFzw5xwVPzrF91LqXJ9k76ScBWX3Untz+6oFc99FazwHmACilwrXWIfkfqshJznPBk3Nc8OQcFzw5x/ahlAq/l+fZewr4Hmzd9QANgMh73EcIIYQQd8neLf2VwFalVADQGeinlHpHaz3+b/ZpZucYhRBCiCLJri19rfUVbBP1fgPaaa0P3JTwb7fP5VwOO6cAQhW3kvNc8OQcFzw5xwVPzrF93NN5VrKKlBBCCFE8SFk3IYQQopgwTNJXSs1TSu1USo2/n33EneV2/pRSXkqptUqp9UqpFUopk71jLAry+jlVSvkrpfbZK66i5C7O8adKqa72iqsoycP3hY9S6kelVLhS6nN7x1dUZH4PbM1lnzznPkMk/ZxV+oAHlFI172UfcWd5PH8DgRla638A0UAne8ZYFNzl5/RDrl++KvIor+dYKdUaKK+1Xm3XAIuAPJ7jJ4HFmZfvlVJKyWV8d0kp5QN8ha1+zZ32uavcZ4ikz+2r9N3LPuLOQsnl/GmtP9Vab8i8Ww6IsU9oRUooeficKqXaY6slHW2fsIqUUHI5x0opV2AuEKmUesJ+oRUZoeT+OY4H6imlvIHKwHn7hFakZAB9gSt/s08od5H7jJL0b67S53+P+4g7y/P5U0o1B3y01r/ZI7AiJtfznDlsMgF43Y5xFSV5+Sw/BRwFpgJNlFKj7BRbUZGXc7wNCAReAI5l7ifugtb6Sh6uYLur3GeUpJ8vlfzE38rT+VNK+QIzgX/ZKa6iJi/n+XXgU611ot2iKlryco4bAnO01tHAIqCdnWIrKvJyjicCz2itJwPHgaF2iq24uavcZ5TEKJX8Cl6u5y+zBfpf4A2t9Vn7hVak5OVz+gjwnFJqMxCklPrCPqEVGXk5x6eBBzJvh2Bb6kLkXV7OsQ/wsFLKGWgKyPXhBeOucp8hrtNXSpUGtgIbyazkB/TOWdjnNvs0y0O3iMiUx3M8EngPOJD50Gyt9VJ7x2pkeTnPN+2/WWsdar8IjS+Pn+VSwJfYukJdgV5a66jbHE7cRh7PcRNgPrYu/p1Ad611kgPCNbys7wGl1EPAgPvJfYZI+pA9i7Ej8Gtml9w97SPuTM6ffch5LnhyjguenOPC427+Xxgm6QshhBDi/hhlTF8IIYQQ90mSvhBCCFFMSNIXQhQ4pZSzUko5Og4hijtJ+kIUEUqpbkqpFnfY5l6QayUopR5VSr2c4/4UpdS6HLu8BazOvHwrL8cbmFkESgiRj1wcHYAQIt9MAH5RSs3Adl10ljeAqkB/pZTGVsDjOa315wBKqYZAKrlfR+0MuAOHtNbmm7ZdBsYppfy01q8BaUBK5vG7AGOxXWqUkfNJmeVwXYA0rbU1x6Z/AdeArjn2dQZMgFVrnZZLrEKI25CkL0QRoJSqAjwMPA40AdpprTcrpRZgS6jPAM9k7rsZWxWvLL9hS9I5k64JW4LPWfPbKfPxWmQWs1FKuQEK+B14DPg48xr4nF4CRmqts1ZmdNJap2Zu6wv8B0hRSmUlcldsP0AsSqnIHMdxBTywLUT0bp5OjBDiBpL0hSgaBgN7tNZRma353GS3uLXWbjdvVEoNASZpravmcpwPgBdveiz7h0KOWDoopeZn3l4FdMu8vSTzvz9preMyn7ME8M7cJwjYrbW2Zq4e9hi2MtBCiHsgY/pCGJxSygV4GltrPcumzIQ7GHBXSv2slLqqlErEVrLzjkt13qVJQBnAVWutgBrAX8BJbMm9DvA9tuEFJ2y9B/1zPL8E0Aw4qZTqqJRaBpTHVrd9HLAF6KyU+hcQDlTIPIYQ4h5IS18I4xuKbZw+p3Za681Zd5RSH2Prvk/Tt6nIpZR6EbimtZ57Ny+cc1GgzOWAv8n8u4ptUZskbD8wDgMva63n3PT8JOB5pdQcwAz0xNZTsAHbD4LuWus1mfMOBmutV95NfEKIG0lLXwgDyxzLfx/49A7b3ZVSftiWku0PDFZKDVFK1btp145Am5sec1JKeef4K6uUqnCb12iQ2SW/GpiitX4J29i/m9b6z8xjTwRmKaVWZ8Zzs2QgEdu8hPbY5gkMAioqpYKxrc1eQy77E+L+SNIXwtguYEuoe256PKt7PwWoDEwDBmIbJ58B1Lxpfws5xvkzVQYu5fiLBdbm3EEp1RjYi22CXZDW+uMccSUqpZy1zQxsi4FU4abvHaVUZ2AX0AFbr8AqbLP3lwOPYlsYpyq2qxCWKaU8cjspQojbk6QvhIFprS1a6//cZlO7zDH2EtiS8o/Af7TW3bB1o4fn4fBntdYq6w/b7Pmb6wAcBupqrZ/QWp+6aVsTclwRoLX+OfOx7CsHlFLjgK+x9UQcw7YaWyngE2yXATYF6gLB2JbArY9txr8Q4h7ImL4QRVRmV3hWd/jPQCel1EFsY/fn7/Z4WmsLth6BnNYCbf+m1916h21KKeUEfAt8p7U+nflgU2zrgc8DzmitR2cu0Xpea/2XUioI0Jk9CDf3TAghciFJX4iiaVOO29WA/2GriqeBWfn4Ol0yj5ldXEcpVQvYD0QBq7XWY7J2zrxOP+sSwYexDUuYlVI3F/spie0Hw5Acz4XrtQIexTazXwhxFyTpC1E0ZRXncQUsWmutlFqPbay8fH69iNb6Ws77SqkAYDG2Lvu3gR2ZPQ5vaK1TMiv5mTOfe4A7fAcppVYCkVrr0fkVqxBCxvSFKCqcuf7v2TXrQa11OuCplJoAdAIOAF8qpfwzF8EJUkrVwXbJn5dSqrZSqja26+Fds+5n/j2UuX+Nm19cKVVGKTUGWwv/GPCC1voC0BzbWPxhpdQopZRXwZ0CIURupKUvRNHgzvWiNdkV9jIX4PkJ24z4YGyz8D8CjmKbFLeLG+vu/3bTcW++75p5vJ6Zxx+N7VLAhsARYITWekXWzpnj8KFAGLZCPjOUUku11oNyeT85f8QIIfKJurkQJzwAAABzSURBVE2dDiFEEaKU8tdaX7zpsbJZZW/v89gtgUeAlZnd9X+3rxu2SwYvaK235rLvBiBCax12vzEKIa6TpC+EEEIUE9J9JoQQQhQTkvSFEEKIYkKSvhBCCFFMSNIXQgghiglJ+kIIIUQxIUlfCCGEKCb+Hw2SquJa9wQcAAAAAElFTkSuQmCC\n",
      "text/plain": [
       "<Figure size 576x432 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.figure(figsize=(8,6)) # plt继承了上面的图片，所以SGD也显示了\n",
    "plt.plot(fpr,tpr,'b:',linewidth=2,label='SGD')\n",
    "plot_roc_curve(fpr_forest,tpr_forest,'Random Forest')\n",
    "plot_roc_curve(fpr_tree,tpr_tree,'Decision Tree')\n",
    "plt.legend(loc='lower right',fontsize=16)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 95,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.metrics import roc_auc_score"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 96,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.9113955975920041"
      ]
     },
     "execution_count": 96,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 计算roc auc分数\n",
    "roc_auc_score(y_train_5,y_score_tree)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 垃圾邮件分类"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 得到所有邮件名，形成列表"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 87,
   "metadata": {},
   "outputs": [],
   "source": [
    "import os\n",
    "SPAM_PATH = os.path.join('datasets','spam')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 88,
   "metadata": {},
   "outputs": [],
   "source": [
    "HAM_DIR = os.path.join(SPAM_PATH,'easy_ham') # HAM_DIR代表正常邮件路径\n",
    "SPAM_DIR = os.path.join(SPAM_PATH,'spam') # SPAM_DIR代表垃圾邮件路径\n",
    "# os.listdir 获取目录中的所有文件信息，形成列表\n",
    "ham_filenames = [name for name in sorted(os.listdir(HAM_DIR)) if len(name) > 20] # sorted对列表排序\n",
    "spam_filenames = [name for name in sorted(os.listdir(SPAM_DIR)) if len(name) > 20]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 89,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 我们可以使用python的email模块解析这些电子邮件（它处理邮件头、编码等）\n",
    "import email\n",
    "import email.policy\n",
    "\n",
    "def load_email(is_spam,filename,spam_path = SPAM_PATH):\n",
    "    directory = 'spam' if is_spam else 'easy_ham'\n",
    "    with open(os.path.join(spam_path,directory,filename), 'rb') as f:\n",
    "        return email.parser.BytesParser(policy=email.policy.default).parse(f)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 90,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Martin A posted:\n",
      "Tassos Papadopoulos, the Greek sculptor behind the plan, judged that the\n",
      " limestone of Mount Kerdylio, 70 miles east of Salonika and not far from the\n",
      " Mount Athos monastic community, was ideal for the patriotic sculpture. \n",
      " \n",
      " As well as Alexander's granite features, 240 ft high and 170 ft wide, a\n",
      " museum, a restored amphitheatre and car park for admiring crowds are\n",
      "planned\n",
      "---------------------\n",
      "So is this mountain limestone or granite?\n",
      "If it's limestone, it'll weather pretty fast.\n",
      "\n",
      "------------------------ Yahoo! Groups Sponsor ---------------------~-->\n",
      "4 DVDs Free +s&p Join Now\n",
      "http://us.click.yahoo.com/pt6YBB/NXiEAA/mG3HAA/7gSolB/TM\n",
      "---------------------------------------------------------------------~->\n",
      "\n",
      "To unsubscribe from this group, send an email to:\n",
      "forteana-unsubscribe@egroups.com\n",
      "\n",
      " \n",
      "\n",
      "Your use of Yahoo! Groups is subject to http://docs.yahoo.com/info/terms/\n"
     ]
    }
   ],
   "source": [
    "# 让我们看一个ham示例和一个spam示例，了解数据的外观\n",
    "ham_emails = [load_email(is_spam = False,filename = name) for name in ham_filenames]\n",
    "spam_emails = [load_email(is_spam = True,filename = name) for name in spam_filenames]\n",
    "print(ham_emails[1].get_content().strip())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 91,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Help wanted.  We are a 14 year old fortune 500 company, that is\n",
      "growing at a tremendous rate.  We are looking for individuals who\n",
      "want to work from home.\n",
      "\n",
      "This is an opportunity to make an excellent income.  No experience\n",
      "is required.  We will train you.\n",
      "\n",
      "So if you are looking to be employed from home with a career that has\n",
      "vast opportunities, then go:\n",
      "\n",
      "http://www.basetel.com/wealthnow\n",
      "\n",
      "We are looking for energetic and self motivated people.  If that is you\n",
      "than click on the link and fill out the form, and one of our\n",
      "employement specialist will contact you.\n",
      "\n",
      "To be removed from our link simple go to:\n",
      "\n",
      "http://www.basetel.com/remove.html\n",
      "\n",
      "\n",
      "4139vOLW7-758DoDY1425FRhM1-764SMFc8513fCsLl40\n"
     ]
    }
   ],
   "source": [
    "print(spam_emails[6].get_content().strip())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 92,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 电子邮件实际上有很多部分，带有图像和附件（它们可以有自己的附件），查看邮件的各种类型的结构\n",
    "def get_email_structure(email):\n",
    "    if isinstance(email,str): # 判断类型，是True，否False，相当于type(email) == str 算法  区别type不认父类子类，isinstance认子类\n",
    "        return email\n",
    "    payload = email.get_payload()  # mail.get_payload()获取邮件的组成部分，返回的要么是字符串要么是列表，列表中是EmaileMessage\n",
    "    if isinstance(payload,list):  # 如果payload是列表\n",
    "        return 'multipart({})'.format(','.join({\n",
    "            get_email_structure(sub_email)\n",
    "            for sub_email in payload\n",
    "        }))\n",
    "    else:\n",
    "        return email.get_content_type() # 如果不是，返回邮件内容类型"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 93,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Counter({1: 1, 4: 2, 2: 3, 3: 2})"
      ]
     },
     "execution_count": 93,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from collections import Counter\n",
    "a = [1,4,2,3,2,3,4,2]\n",
    "b = Counter(a)  # 求数组中每个数组出现了几次\n",
    "\n",
    "b"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 94,
   "metadata": {},
   "outputs": [],
   "source": [
    "def structures_counter(emails):\n",
    "    structures = Counter()\n",
    "    for email in emails:\n",
    "        structure = get_email_structure(email)\n",
    "        structures[structure] += 1\n",
    "    return structures"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 95,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[('text/plain', 2408),\n",
       " ('multipart(text/plain,application/pgp-signature)', 66),\n",
       " ('multipart(text/plain,text/html)', 8),\n",
       " ('multipart(text/plain)', 7),\n",
       " ('multipart(text/plain,application/octet-stream)', 2),\n",
       " ('multipart(text/plain,text/enriched)', 1),\n",
       " ('multipart(text/plain,application/ms-tnef)', 1),\n",
       " ('multipart(multipart(text/plain),application/pgp-signature)', 1),\n",
       " ('multipart(text/plain,video/mng)', 1),\n",
       " ('multipart(text/plain,multipart(text/plain))', 1),\n",
       " ('multipart(text/plain,application/x-pkcs7-signature)', 1),\n",
       " ('multipart(text/plain,multipart(text/plain),text/rfc822-headers)', 1),\n",
       " ('multipart(text/plain,multipart(multipart(text/plain,application/x-pkcs7-signature)),multipart(text/plain))',\n",
       "  1),\n",
       " ('multipart(text/plain,application/x-java-applet)', 1)]"
      ]
     },
     "execution_count": 95,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "structures_counter(ham_emails).most_common()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 96,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[('text/plain', 218),\n",
       " ('text/html', 183),\n",
       " ('multipart(text/plain,text/html)', 45),\n",
       " ('multipart(text/html)', 20),\n",
       " ('multipart(text/plain)', 19),\n",
       " ('multipart(multipart(text/html))', 5),\n",
       " ('multipart(text/plain,image/jpeg)', 3),\n",
       " ('multipart(text/html,application/octet-stream)', 2),\n",
       " ('multipart(text/plain,application/octet-stream)', 1),\n",
       " ('multipart(text/html,text/plain)', 1),\n",
       " ('multipart(application/octet-stream,multipart(text/html),image/jpeg)', 1),\n",
       " ('multipart(multipart(text/plain,text/html),image/gif)', 1),\n",
       " ('multipart/alternative', 1)]"
      ]
     },
     "execution_count": 96,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "structures_counter(spam_emails).most_common()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 97,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Return-Path : <12a1mailbot1@web.de>\n",
      "Delivered-To : zzzz@localhost.spamassassin.taint.org\n",
      "Received : from localhost (localhost [127.0.0.1])\tby phobos.labs.spamassassin.taint.org (Postfix) with ESMTP id 136B943C32\tfor <zzzz@localhost>; Thu, 22 Aug 2002 08:17:21 -0400 (EDT)\n",
      "Received : from mail.webnote.net [193.120.211.219]\tby localhost with POP3 (fetchmail-5.9.0)\tfor zzzz@localhost (single-drop); Thu, 22 Aug 2002 13:17:21 +0100 (IST)\n",
      "Received : from dd_it7 ([210.97.77.167])\tby webnote.net (8.9.3/8.9.3) with ESMTP id NAA04623\tfor <zzzz@spamassassin.taint.org>; Thu, 22 Aug 2002 13:09:41 +0100\n",
      "From : 12a1mailbot1@web.de\n",
      "Received : from r-smtp.korea.com - 203.122.2.197 by dd_it7  with Microsoft SMTPSVC(5.5.1775.675.6);\t Sat, 24 Aug 2002 09:42:10 +0900\n",
      "To : dcek1a1@netsgo.com\n",
      "Subject : Life Insurance - Why Pay More?\n",
      "Date : Wed, 21 Aug 2002 20:31:57 -1600\n",
      "MIME-Version : 1.0\n",
      "Message-ID : <0103c1042001882DD_IT7@dd_it7>\n",
      "Content-Type : text/html; charset=\"iso-8859-1\"\n",
      "Content-Transfer-Encoding : quoted-printable\n"
     ]
    }
   ],
   "source": [
    "# 正常邮件更多的是纯文本，而垃圾邮件有相当多的HTML\n",
    "# 查看邮件头\n",
    "for header, value in spam_emails[0].items():\n",
    "    print(header,':',value)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 98,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Life Insurance - Why Pay More?'"
      ]
     },
     "execution_count": 98,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 里面可能有很多有用的信息，比如发件人的电邮地址（12a1mailbot1@web.de看起来很可疑）\n",
    "# 查看主题标题\n",
    "spam_emails[0]['Subject']"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 拆分训练集和测试集"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 99,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.model_selection import train_test_split\n",
    "\n",
    "X = np.array(ham_emails + spam_emails)\n",
    "y = np.array([0] * len(ham_emails) + [1] * len(spam_emails))\n",
    "X_train, X_test, y_train,y_test = train_test_split(X, y, test_size = 0.2, random_state = 42)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 首先需要一个函数来将html转换为纯文本，使用[Beautifulsoup]库，下面的函数首先删除`<head>`部分，然后将所有`<a>`标记转换为单词hyperlink，然后去掉所有html标记，只留下纯文本。为了可读性，它还用一个换行符替换多个换行符，最后它取消了HTML实体（例如`&gt；`或`&nbsp；`）"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 100,
   "metadata": {},
   "outputs": [],
   "source": [
    "import re\n",
    "from html import unescape\n",
    "\n",
    "def html_to_plain_text(html):\n",
    "    text = re.sub('<head.*?>.*?</head>', '',html, flags=re.M | re.S | re.I)\n",
    "    text = re.sub('<a\\s.*?>', 'HYPERLINK', text, flags=re.M | re.S | re.I)\n",
    "    text = re.sub('<.*?>', '',text, flags=re.M | re.S)\n",
    "    text = re.sub(r'(\\s*\\n)+', '\\n',text, flags=re.M | re.S)\n",
    "    return unescape(text)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 101,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<HTML><HEAD><TITLE></TITLE><META http-equiv=\"Content-Type\" content=\"text/html; charset=windows-1252\"><STYLE>A:link {TEX-DECORATION: none}A:active {TEXT-DECORATION: none}A:visited {TEXT-DECORATION: none}A:hover {COLOR: #0033ff; TEXT-DECORATION: underline}</STYLE><META content=\"MSHTML 6.00.2713.1100\" name=\"GENERATOR\"></HEAD>\n",
      "<BODY text=\"#000000\" vLink=\"#0033ff\" link=\"#0033ff\" bgColor=\"#CCCC99\"><TABLE borderColor=\"#660000\" cellSpacing=\"0\" cellPadding=\"0\" border=\"0\" width=\"100%\"><TR><TD bgColor=\"#CCCC99\" valign=\"top\" colspan=\"2\" height=\"27\">\n",
      "<font size=\"6\" face=\"Arial, Helvetica, sans-serif\" color=\"#660000\">\n",
      "<b>OTC</b></font></TD></TR><TR><TD height=\"2\" bgcolor=\"#6a694f\">\n",
      "<font size=\"5\" face=\"Times New Roman, Times, serif\" color=\"#FFFFFF\">\n",
      "<b>&nbsp;Newsletter</b></font></TD><TD height=\"2\" bgcolor=\"#6a694f\"><div align=\"right\"><font color=\"#FFFFFF\">\n",
      "<b>Discover Tomorrow's Winners&nbsp;</b></font></div></TD></TR><TR><TD height=\"25\" colspan=\"2\" bgcolor=\"#CCCC99\"><table width=\"100%\" border=\"0\"  ...\n"
     ]
    }
   ],
   "source": [
    "html_spam_emails = [email for email in X_train[y_train == 1]\n",
    "                   if get_email_structure(email) == 'text/html']\n",
    "sample_html_spam = html_spam_emails[7]\n",
    "print(sample_html_spam.get_content().strip()[:1000],'...')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 102,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "OTC\n",
      " Newsletter\n",
      "Discover Tomorrow's Winners \n",
      "For Immediate Release\n",
      "Cal-Bay (Stock Symbol: CBYI)\n",
      "Watch for analyst \"Strong Buy Recommendations\" and several advisory newsletters picking CBYI.  CBYI has filed to be traded on the OTCBB, share prices historically INCREASE when companies get listed on this larger trading exchange. CBYI is trading around 25 cents and should skyrocket to $2.66 - $3.25 a share in the near future.\n",
      "Put CBYI on your watch list, acquire a position TODAY.\n",
      "REASONS TO INVEST IN CBYI\n",
      "A profitable company and is on track to beat ALL earnings estimates!\n",
      "One of the FASTEST growing distributors in environmental & safety equipment instruments.\n",
      "Excellent management team, several EXCLUSIVE contracts.  IMPRESSIVE client list including the U.S. Air Force, Anheuser-Busch, Chevron Refining and Mitsubishi Heavy Industries, GE-Energy & Environmental Research.\n",
      "RAPIDLY GROWING INDUSTRY\n",
      "Industry revenues exceed $900 million, estimates indicate that there could be as much as $25 billi ...\n"
     ]
    }
   ],
   "source": [
    "print(html_to_plain_text(sample_html_spam.get_content())[:1000],'...')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 103,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 编写一个函数，它以电子邮件为输入，并以纯文本形式返回其内容，无论其格式是什么\n",
    "def email_to_text(email):\n",
    "    html = None\n",
    "    for part in email.walk():\n",
    "        ctype = part.get_content_type()\n",
    "        if not ctype in ('text/plain','text/html'):\n",
    "            continue\n",
    "        try:\n",
    "            content = part.get_content()\n",
    "        except: # 解决编码问题\n",
    "            content = str(part.get_payload())\n",
    "        if ctype == 'text/plain':\n",
    "            return content\n",
    "        else:\n",
    "            html = content\n",
    "        if html:\n",
    "            return html_to_plain_text(html)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 104,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "OTC\n",
      " Newsletter\n",
      "Discover Tomorrow's Winners \n",
      "For Immediate Release\n",
      "Cal-Bay (Stock Symbol: CBYI)\n",
      "Watch for analyst \"Strong Buy Recommendations\" and several advisory newsletters picking CBYI.  CBYI has filed to be traded on the OTCBB, share prices historically INCREASE when companies get listed on this larger trading exchange. CBYI is trading around 25 cents and should skyrocket to $2.66 - $3.25 a share in the near future.\n",
      "Put CBYI on your watch list, acquire a position TODAY.\n",
      "REASONS TO INVEST IN CBYI\n",
      "A profitable company and is on track to beat ALL earnings estimates!\n",
      "One of the FASTEST growing distributors in environmental & safety equipment instruments.\n",
      "Excellent management team, several EXCLUSIVE contracts.  IMPRESSIVE client list including the U.S. Air Force, Anheuser-Busch, Chevron Refining and Mitsubishi Heavy Industries, GE-Energy & Environmental Research.\n",
      "RAPIDLY GROWING INDUSTRY\n",
      "Industry revenues exceed $900 million, estimates indicate that there could be as much as $25 billi ...\n"
     ]
    }
   ],
   "source": [
    "print(email_to_text(sample_html_spam)[:1000],'...')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 105,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Computations => comput\n",
      "Computation => comput\n",
      "Computing => comput\n",
      "Computed => comput\n",
      "Compute => comput\n",
      "Compulsive => compuls\n"
     ]
    }
   ],
   "source": [
    "# 装自然语言工具包（[nltk]（http://www.nltk.org/）\n",
    "# pip install nltk\n",
    "\n",
    "# 用“url”替换url的方法 \n",
    "# pip install urlextract\n",
    "import nltk\n",
    "from urlextract import URLExtract\n",
    "\n",
    "try:\n",
    "    import nltk\n",
    "\n",
    "    stemmer = nltk.PorterStemmer()\n",
    "    for word in (\"Computations\", \"Computation\", \"Computing\", \"Computed\", \"Compute\", \"Compulsive\"):\n",
    "        print(word, \"=>\", stemmer.stem(word))\n",
    "except ImportError:\n",
    "    print(\"Error: stemming requires the NLTK module.\")\n",
    "    stemmer = None\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 将所有处理整合到一个转换器中，我们将使用它将电子邮件转换为文字计数器。注意，我们使用python的'split（）'方法将句子拆分为单词，该方法使用空格作为单词边界。但例如，汉语和日语脚本通常不在单词之间使用空格在这个练习中没关系，因为数据集（主要）是英文的，中文可以使用结巴分词来进行拆分"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 106,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.base import BaseEstimator, TransformerMixin\n",
    "\n",
    "class EmailToWordCounterTransformer(BaseEstimator, TransformerMixin):\n",
    "    def __init__(self, strip_headers=True, lower_case=True, remove_punctuation=True,\n",
    "                 replace_urls=True, replace_numbers=True,  stemming=True):\n",
    "        self.strip_headers = strip_headers\n",
    "        self.lower_case = lower_case\n",
    "        self.remove_punctuation = remove_punctuation\n",
    "        self.replace_urls = replace_urls\n",
    "        self.replace_numbers = replace_numbers\n",
    "        self.stemming = stemming\n",
    "    def fit(self, X, y=None):\n",
    "        return self\n",
    "    def transform(self, X, y=None):\n",
    "        X_transformed = []\n",
    "        for email in X:\n",
    "            text = email_to_text(email) or \"\"\n",
    "            if self.lower_case:\n",
    "                text = text.lower()\n",
    "            if self.replace_urls:\n",
    "                extractor = URLExtract()\n",
    "                urls = list(set(extractor.find_urls(text)))\n",
    "                urls.sort(key=lambda url: len(url), reverse=True)\n",
    "                for url in urls:  # 替换url 为 ‘URL’\n",
    "                    text = text.replace(url, \" URL \")\n",
    "            if self.replace_numbers:  # 替换数字\n",
    "                text = re.sub(r'\\d+(?:\\.\\d*(?:[eE]\\d+))?', 'NUMBER', text)\n",
    "            if self.remove_punctuation:  # 删除标点符号\n",
    "                text = re.sub(r'\\W+', ' ', text, flags=re.M)\n",
    "            word_counts = Counter(text.split())\n",
    "            if self.stemming and stemmer is not None:\n",
    "                stemmed_word_counts = Counter()\n",
    "                for word, count in word_counts.items():\n",
    "                    stemmed_word = stemmer.stem(word)\n",
    "                    stemmed_word_counts[stemmed_word] += count\n",
    "                word_counts = stemmed_word_counts\n",
    "            X_transformed.append(word_counts)\n",
    "        return np.array(X_transformed)\n",
    "    \n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 107,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([Counter({'chuck': 1, 'murcko': 1, 'wrote': 1, 'stuff': 1, 'yawn': 1, 'r': 1}),\n",
       "       Counter({'the': 11, 'of': 9, 'and': 8, 'all': 3, 'christian': 3, 'to': 3, 'by': 3, 'jefferson': 2, 'i': 2, 'have': 2, 'superstit': 2, 'one': 2, 'on': 2, 'been': 2, 'ha': 2, 'half': 2, 'rogueri': 2, 'teach': 2, 'jesu': 2, 'some': 1, 'interest': 1, 'quot': 1, 'url': 1, 'thoma': 1, 'examin': 1, 'known': 1, 'word': 1, 'do': 1, 'not': 1, 'find': 1, 'in': 1, 'our': 1, 'particular': 1, 'redeem': 1, 'featur': 1, 'they': 1, 'are': 1, 'alik': 1, 'found': 1, 'fabl': 1, 'mytholog': 1, 'million': 1, 'innoc': 1, 'men': 1, 'women': 1, 'children': 1, 'sinc': 1, 'introduct': 1, 'burnt': 1, 'tortur': 1, 'fine': 1, 'imprison': 1, 'what': 1, 'effect': 1, 'thi': 1, 'coercion': 1, 'make': 1, 'world': 1, 'fool': 1, 'other': 1, 'hypocrit': 1, 'support': 1, 'error': 1, 'over': 1, 'earth': 1, 'six': 1, 'histor': 1, 'american': 1, 'john': 1, 'e': 1, 'remsburg': 1, 'letter': 1, 'william': 1, 'short': 1, 'again': 1, 'becom': 1, 'most': 1, 'pervert': 1, 'system': 1, 'that': 1, 'ever': 1, 'shone': 1, 'man': 1, 'absurd': 1, 'untruth': 1, 'were': 1, 'perpetr': 1, 'upon': 1, 'a': 1, 'larg': 1, 'band': 1, 'dupe': 1, 'import': 1, 'led': 1, 'paul': 1, 'first': 1, 'great': 1, 'corrupt': 1}),\n",
       "       Counter({'url': 4, 's': 3, 'group': 3, 'to': 3, 'in': 2, 'forteana': 2, 'martin': 2, 'an': 2, 'and': 2, 'we': 2, 'is': 2, 'yahoo': 2, 'unsubscrib': 2, 'y': 1, 'adamson': 1, 'wrote': 1, 'for': 1, 'altern': 1, 'rather': 1, 'more': 1, 'factual': 1, 'base': 1, 'rundown': 1, 'on': 1, 'hamza': 1, 'career': 1, 'includ': 1, 'hi': 1, 'belief': 1, 'that': 1, 'all': 1, 'non': 1, 'muslim': 1, 'yemen': 1, 'should': 1, 'be': 1, 'murder': 1, 'outright': 1, 'know': 1, 'how': 1, 'unbias': 1, 'memri': 1, 'don': 1, 't': 1, 'html': 1, 'rob': 1, 'sponsor': 1, 'number': 1, 'dvd': 1, 'free': 1, 'p': 1, 'join': 1, 'now': 1, 'from': 1, 'thi': 1, 'send': 1, 'email': 1, 'egroup': 1, 'com': 1, 'your': 1, 'use': 1, 'of': 1, 'subject': 1})],\n",
       "      dtype=object)"
      ]
     },
     "execution_count": 107,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 在一些邮件上，测试转换器\n",
    "X_few = X_train[:3]\n",
    "X_few_wordcounts = EmailToWordCounterTransformer().fit_transform(X_few)\n",
    "X_few_wordcounts"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 有了单词计数，我们需要把它们转换成向量。为此，我们将构建另一个转换器，其“fit（）”方法将构建词汇表（最常用单词的有序列表），其“transform（）”方法将使用词汇表将单词计数转换为向量--稀疏矩阵"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 108,
   "metadata": {},
   "outputs": [],
   "source": [
    "from scipy.sparse import csr_matrix\n",
    "\n",
    "class WordCounterToVectorTransformer(BaseEstimator, TransformerMixin):\n",
    "    def __init__(self, vocabulary_size = 1000):\n",
    "        self.vocabulary_size = vocabulary_size  # 词汇量\n",
    "    def fit(self, X, y = None):\n",
    "        total_count = Counter()\n",
    "        for word_count in X:\n",
    "            for word, count in word_count.items():\n",
    "                total_count[word] += min(count, 10)\n",
    "        most_common = total_count.most_common()[:self.vocabulary_size]\n",
    "        self.most_common_ = most_common\n",
    "        self.vocabulary_ = {word: index + 1 for index, (word, count) in enumerate(most_common)}\n",
    "        return self\n",
    "    def transform(self, X, y = None):\n",
    "        rows = []\n",
    "        cols = []\n",
    "        data = []\n",
    "        for row, word_count in enumerate(X):\n",
    "            for word, count in word_count.items():\n",
    "                rows.append(row) # 训练集 实例个数\n",
    "                cols.append(self.vocabulary_.get(word, 0)) # 取得单词在词汇表中的索引位置，0代表未出现在词汇表中\n",
    "                data.append(count)\n",
    "        return csr_matrix((data, (rows, cols)), shape=(len(X), self.vocabulary_size + 1)) \n",
    "    # 输出稀疏矩阵 +1因为第一列要显示未出现在词汇表中的单词统计数"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 109,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "  (0, 0)\t1\n",
      "  (0, 1)\t0\n",
      "  (0, 2)\t1\n",
      "  (1, 0)\t0\n",
      "  (1, 1)\t1\n",
      "  (1, 2)\t1\n",
      "  (2, 0)\t1\n",
      "  (2, 1)\t1\n",
      "  (2, 2)\t0\n",
      "[[1 0 1]\n",
      " [0 1 1]\n",
      " [1 1 0]]\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "array([[1, 0, 1],\n",
       "       [0, 1, 1],\n",
       "       [1, 1, 0]], dtype=int32)"
      ]
     },
     "execution_count": 109,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from scipy.sparse import *\n",
    " \n",
    "row =  [0,0,0,1,1,1,2,2,2]#行指标\n",
    "col =  [0,1,2,0,1,2,0,1,2]#列指标\n",
    "data = [1,0,1,0,1,1,1,1,0]#在行指标列指标下的数字\n",
    "team = csr_matrix((data,(row,col)),shape=(3,3))\n",
    "print(team)\n",
    "print(team.todense())\n",
    "team.toarray()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 110,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(3, 11)"
      ]
     },
     "execution_count": 110,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "vocab_transformer = WordCounterToVectorTransformer(vocabulary_size=10)\n",
    "X_few_vectors = vocab_transformer.fit_transform(X_few_wordcounts)\n",
    "X_few_vectors.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 111,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 6,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0],\n",
       "       [99, 11,  9,  8,  3,  1,  3,  1,  3,  2,  3],\n",
       "       [67,  0,  1,  2,  3,  4,  1,  2,  0,  1,  0]], dtype=int32)"
      ]
     },
     "execution_count": 111,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "X_few_vectors.toarray()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 第三行第一列中的67表示第三封电子邮件包含64个不属于词汇表的单词。旁边的1表示词汇表中'of'单词在此电子邮件中出现一次。旁边的2表示'and'单词出现两次,'the'没有出现"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 112,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'the': 1,\n",
       " 'of': 2,\n",
       " 'and': 3,\n",
       " 'to': 4,\n",
       " 'url': 5,\n",
       " 'all': 6,\n",
       " 'in': 7,\n",
       " 'christian': 8,\n",
       " 'on': 9,\n",
       " 'by': 10}"
      ]
     },
     "execution_count": 112,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "vocab_transformer.vocabulary_"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 我们现在准备训练我们的第一个垃圾邮件分类器！让我们转换整个数据集："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 113,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.pipeline import Pipeline\n",
    "preprocess_pipeline = Pipeline([\n",
    "    ('email_to_wordcount', EmailToWordCounterTransformer()),\n",
    "    ('wordcount_to_vector',WordCounterToVectorTransformer())\n",
    "])\n",
    "X_train_transformed = preprocess_pipeline.fit_transform(X_train)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 114,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[CV]  ................................................................\n",
      "[CV] .................................. , score=0.98125, total=   0.0s\n",
      "[CV]  ................................................................\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "[Parallel(n_jobs=1)]: Done   1 out of   1 | elapsed:    0.1s remaining:    0.0s\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[CV] ................................... , score=0.9825, total=   0.1s\n",
      "[CV]  ................................................................\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "[Parallel(n_jobs=1)]: Done   2 out of   2 | elapsed:    0.3s remaining:    0.0s\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[CV] ................................... , score=0.9925, total=   0.4s\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "[Parallel(n_jobs=1)]: Done   3 out of   3 | elapsed:    0.8s finished\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "0.9854166666666667"
      ]
     },
     "execution_count": 114,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from sklearn.linear_model import LogisticRegression\n",
    "from sklearn.model_selection import cross_val_score\n",
    "\n",
    "log_clf = LogisticRegression(solver='liblinear', random_state=42) # 采用逻辑回归分类器\n",
    "score = cross_val_score(log_clf,X_train_transformed,y_train,cv=3,verbose=3)\n",
    "score.mean()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 得到分数超过98.7%，可以尝试多个模型，选择最好的模型，并使用交叉验证对它们进行微调。在测试集上得到的精度/召回率："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 115,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "精度：94.90%\n",
      "召回：97.89%\n"
     ]
    }
   ],
   "source": [
    "from sklearn.metrics import precision_recall_curve,recall_score\n",
    "\n",
    "X_test_transformed = preprocess_pipeline.transform(X_test)\n",
    "log_clf = LogisticRegression(solver='liblinear', random_state=42)\n",
    "log_clf.fit(X_train_transformed,y_train)\n",
    "\n",
    "y_pred = log_clf.predict(X_test_transformed)\n",
    "print('精度：{:.2f}%'.format(100 * precision_score(y_test,y_pred)))\n",
    "print('召回：{:.2f}%'.format(100 * recall_score(y_test,y_pred)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 总结\n",
    "1. 加载数据并纵观数据大局\n",
    "2. 获取邮件的组成结构\n",
    "3. 对结构类型进行分析 发现垃圾邮件大多有HTML结构\n",
    "4. 数据清洗，定义email对象中的HTML转换称纯文本方法\n",
    "5. 对数据集拆分成训练集和测试集\n",
    "6. 数据处理转换，对邮件的文本内容进行分词处理，通过nltk进行词干提取，对邮件出现的词汇进行计数统计，对所有邮件统计出了一个词汇表\n",
    "7. 通过词汇表和邮件单词计数统计，将单词计数转化成向量矩阵\n",
    "8. 把数据清洗和数据处理封装成两个转换器\n",
    "9. 通过流水线来自动化处理数据\n",
    "10. 使用逻辑回归线性分类器进行模型训练\n",
    "11. 使用交叉验证进行微调\n",
    "12. 在测试集上得到精度/召回率"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}
